04 - Tier 3 - Technical Deep Dive

HTML wrapper for HTML-only fetchers; content shown verbatim from source markdown.

Back to index ยท Raw file

# Tier 3 - Technical Deep Dive (Parity Gap + Airgapped Blueprint)

Version: v1.1 (537 Pack)  
Date (UTC): 2026-02-16T10:29:39Z

Distribution authorization:
- Audience tier: external technical due diligence (Tier 3).
- This document is authorized for external security/procurement feasibility review under Pack 537 rules.
- It describes governance architecture and control intent; it is not a replication blueprint or implementation handoff.

## Purpose
This document closes the technical depth gap between Tier 2 external due diligence and implementation planning.

Boundary:
- This is an engineering blueprint and parity analysis.
- This is not a certification claim.

Positioning:
- Rook is not a clone of legacy agent stacks.
- Rook is a governance-first runtime lineage with fail-closed control paths, policy-gated execution, and replayable evidence.

## if_context in Brief
- `if_context` stores mission memory safely in a governed ledger, not in an unbounded prompt transcript.
- At decision time, Rook pulls only policy-allowed context slices with provenance metadata.

## Current Implementation Reality (Code-Backed)
Implemented in current runtime:
1. Policy gate + principal/release verification + chain continuity in the `rook-core` runtime.
2. Long-running mission event runtime through `if.bus` execution channels.
3. `if_context` lifecycle/folding/reframe/pack path in runtime context services.
4. Multi-agent bridge and ping-pong checks in `if_chat` transport validation.
5. Append-only task/signal/session coordination in `if.blackboard` governance services.

Lockstep note:
- Compliance probe is now green in this session (`grade: PASS`, no hard-fail gates).
- Probe endpoint detection was patched to check both `/api/capabilities` and `/capabilities` under the chat base URL.
- Manifest validation now uses cached schema/validator objects to reduce hot-path gate latency.
- T0 perf harness now reports `in_process` vs `subprocess_cli` latency explicitly with threshold `target_mode`.

## Legacy Baseline Gap Matrix (What Is Not Yet Fully Implemented)
The table below enumerates major breadth features present in legacy agent baselines and the recommended airgapped Rook equivalents.

| Legacy Surface | Current Rook State | Airgapped Rook Equivalent | Policy Toggle / Escalation | Target milestone / tracking |
|---|---|---|---|---|
| Multi-channel connectors (chat/social/messaging breadth) | Partial; no broad connector fabric | `Connector Admission Gateway`: signed adapter capsules, schema-locked envelopes, allowlist-only protocols | Default `DENY`; enable per connector by signed policy lease (time-bounded); auto-expire to deny | Phase 1 baseline; Phase 2 hardening |
| Scheduler / recurring long jobs | Partial; event runtime exists, no full production job compiler parity | `Deterministic Job Compiler + DAG Runner`: signed job manifests, idempotent replay, strict lineage IDs | Enable only during approved windows and green gate bundle; freeze on degraded controls | Phase 1 core DAG; Phase 2 replay hardening |
| Hooks + inbound webhook automation | Limited | `Signed Pull Inbox` (not unauthenticated push): nonce/TTL replay checks, quarantine queue, policy re-check per dispatch | Event-based promotion only after dual approval for write scopes | Phase 1 signed inbox; Phase 2 promotion controls |
| Session control APIs/UI (patch/inject/abort at scale) | Partial | `Session Guardrail API`: lease issue/rotate/revoke, no unsigned mutations, breakglass as signed constrained exception | 2-party approval for elevated write leases; hard TTL; immutable receipt required | Phase 1 minimal API; privileged UI deferred to Phase 2+ |
| Browser/canvas automation | Not prioritized | `Isolated Capability Worker` modules (ephemeral sandbox, one-way output gate) | Disabled by default; only enable per mission class after red-team signoff | Phase 3 only after trust-substrate exit criteria |
| Voice/call automation stack | Not prioritized | `Policy-Bound Voice Module` behind same sealed envelope contract | High/critical only with hardware-primary authorization chain | Phase 3 only with deployment proof capsules |
| Broad multi-agent routing/orchestration parity | Partial | `Policy Router v1`: risk-tier route matrix, capability tags, forced handoff on uncertainty | Escalate to safe mode on gate failure rate thresholds; auto-hold release on prolonged degrade | Phase 1 route matrix; Phase 2 escalation automation |

## Core Design Contract (Airgapped-Safe)
Every execution surface must obey one immutable contract:
1. Sealed run envelope exists.
2. Envelope is signed and policy-hash pinned.
3. Runtime gate validates envelope before execution.
4. Execution produces append-only result receipt.
5. Replay verification can reproduce pass/fail decision boundaries.

Minimum envelope fields:
- `policy_hash`
- `module_digest`
- `input_digest`
- `principal_attestation`
- `release_proof_id`
- `attempt_id`
- `lease_id`
- `decision_chain_prev_hash`
- `signature_set`

## Long-Running Mission Model (Weeks, Not Chat Turns)
Mission continuity should remain ledger-first:
- Full history in append-only stores.
- Prompt context is rebuilt on-demand under policy budget.
- Conceptual trust progression: `stored -> used -> trusted`.
- Operational memory-state contract: `candidate -> committed -> tombstoned`.

Lifecycle relation:
- `stored/used/trusted` explains governance intent.
- `candidate/committed/tombstoned` is the enforceable runtime state machine.

## Multi-Rook Coordination + SIP-Like Session Discipline
Coordination model:
- `if_chat` is the real-time coordination plane.
- `if.blackboard` is append-only authority for tasks/signals.
- `if_context` carries evidence-linked state across handoffs.

Session discipline:
- Stable actor identity (`agent_id`) with rotating session identity (`sid`).
- Transport metadata never overrides policy decisions.

Boundary:
- This is coordination identity/session discipline, not a claim of universal SIP telephony replacement.

## 6-Voice Debate (Ping-Pong) Outcome
Debate setup:
- Six independent lenses: Security, Systems, Ops/Policy, Airgap/Supply-Chain, Contrarian/Jester, Customer Reality.
- Three rounds: opening, cross-critique, arbitration.
- Parallel if_chat bridge validation and task-locked arbitration runs executed.
- Transcript artifact: `if_chat_six_voice_debate_browser_connectors_multitenancy_2026-02-16T103000Z.md`

Consensus points:
1. Do not chase feature breadth before trust primitives are complete.
2. Enforce one sealed run-envelope contract across all new surfaces.
3. Keep unsigned execution at absolute zero, including emergency paths.
4. Prioritize deterministic scheduler + policy router + signed connector gateway first.
5. Keep browser/canvas/voice out of near-term scope until envelope compliance is mature.

Non-consensus (resolved by arbitration):
- Whether session control UI ships in Phase 1.
Resolution:
- Ship minimal guardrail API in Phase 1 (no broad privileged UI), full UI deferred.

Browser urgency arbitration:
- Browser automation is accepted as urgent, but only within constrained policy scope (signed envelope + tenant-bound outbound tuple + operator-gate evidence).
- Channel mode boundary remains explicit: Browser/Slack outbound supported in T0; IGDM inbound/shadow; WhatsApp/Telegram not enabled.

## 30-Day Implementation Plan (Phased)
### Phase 1 (Days 1-10): Trust Substrate
1. Seal and enforce run-envelope schema and signature verification path.
2. Finish offline root-of-trust hierarchy and signer rotation automation hooks.
3. Enforce fail-closed deny for unsigned/policy-mismatched execution globally.

Exit criteria:
- `unsigned_launch_acceptance_rate = 0%`
- policy-hash validation coverage = 100%

### Phase 2 (Days 11-20): Deterministic Runtime Expansion
1. Deliver deterministic DAG scheduler with replay verification and quarantine on nondeterminism.
2. Deliver policy router with per-attempt gate tokens and bounded retries.
3. Add signed connector admission gateway (default deny).

Exit criteria:
- governance overhead `p95 <= 25ms`
- replay-verifiable run coverage >= 99.9%

### Phase 3 (Days 21-30): Controlled Surface Growth
1. Release hook/pull-inbox path with nonce/TTL and quarantine.
2. Release minimal session guardrail API with signed, expiring elevated leases.
3. Keep browser/canvas/voice as explicitly deferred backlog.

Exit criteria:
- zero policy bypass write attempts accepted
- zero unauthorized admission events in red-team replay set

## What We Should Explicitly Not Build Yet
Defer until trust substrate metrics are stable:
- Broad browser automation parity
- Broad voice/call automation parity
- High-privilege operator UI features that can mutate runtime without sealed envelopes

## Black/White Status
Verified now:
- Governance-first runtime controls (policy/principal/release/chain).
- Long-running mission continuity model and if_context lifecycle enforcement path.
- Multi-agent bridge capability and if_chat ping-pong health.
- Compliance probe currently green for this session.
- Hot-path policy-check latency target is met in-process (`p95=0.523ms`, `p99=0.599ms`).
- Claims-manifest lint is wired into operator-gate hard-fail decisions.

Not yet fully implemented:
- Full legacy connector breadth parity.
- Full voice/browser/canvas parity under airgapped controls.
- Universal telecom/network interoperability claims.
- Cold-start subprocess CLI latency does not yet meet the stricter p95/p99 threshold without warm process reuse.

## Immediate Build Queue (Actionable)
1. Implement `sealed_job_envelope` schema + verifier in runtime admission path.
2. Build deterministic DAG scheduler artifact with replay verifier CLI.
3. Build connector admission gateway with signed adapter manifest policy.
4. Add per-attempt gate tokens for retry paths in router/scheduler.
5. Ship minimal session guardrail API (lease + dual-approval + immutable receipts).
6. Add warm worker/daemon execution mode for CLI policy checks to close cold-start latency gap.

## Suggested External Answer (When Asked About Legacy Comparison)
- "No. Rook is not a legacy clone. It is a governance-first autonomous runtime lineage designed for high-stakes operations with fail-closed policy gates and replayable evidence continuity."

## if.trace Footer
Black/white:
- `if.trace` receipts verify byte integrity and provenance chain.
- `if.trace` receipts do not prove semantic correctness, safety, or legal compliance by themselves.

Canonical public surfaces (one URL per line):
https://infrafabric.io/if/trace/
https://infrafabric.io/static/trace/<shareId>
https://infrafabric.io/static/pack/<shareId>
https://infrafabric.io/static/pack/<shareId>.md
https://infrafabric.io/static/dossier/<shareId>
https://infrafabric.io/static/dossier/<shareId>/download
https://infrafabric.io/static/source/<sha256>.pdf

Hosted verification tools (one URL per line):
https://infrafabric.io/static/hosted/iftrace.py
https://infrafabric.io/static/hosted/iftrace.html

Reviewer inspectability note:
- Reviewers may inspect `iftrace.py` source directly or independently re-implement verification from the published receipt schema.

Minimal connectivity checks:
```bash
curl -fsSI https://infrafabric.io/if/trace/ | head -n 5
curl -fsSI https://infrafabric.io/static/hosted/iftrace.py | head -n 5
```
These commands confirm endpoint reachability. Content verification requires running `iftrace.py` (or equivalent verifier) against a specific receipt or pack artifact.

Quantum posture:
- `PQ receipt` means a receipt explicitly marked with a post-quantum signature profile in receipt metadata.
- Use `QUANTUM READY` only when a PQ receipt exists for the artifact under review.
- Do not claim `quantum-secure` without deployment-specific cryptographic proof.

Receipt metadata discipline:
- Include `product_id`, `product_version`, and `artifact_kind` in published manifests/receipts.