02 - Tier 2 - External Due Diligence Pack

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

Back to index · Raw file

# Tier 2 - External Due Diligence Pack (Evidence & Verification)

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

## Executive Position
Rook is an autonomous runtime governance system for high-stakes operations where decisions must be provable after the fact.

Current external claim boundary:
- Allowed: compliance-grade autonomous runtime governance.
- Not allowed: compliance-certified autonomy.

## Operational Definition of Compliance-Grade (This Pack)
For this external pack, `compliance-grade` means this control baseline:
- Policy-gated execution before side effects.
- Principal and approved release-context verification.
- Tamper-evident evidence continuity (intent/result + chain/anchor/checkpoint).
- Fail-closed behavior when mandatory controls degrade.
- Replayable pass/fail artifacts for operator-gate decisions.

Boundary note:
- This is an operational control baseline, not a claim of external certification.
- This is not a claim of meeting any specific law/framework unless separately attested.
- For due-diligence alignment, common reference families include NIST SP 800-63B, FIDO2/WebAuthn, and ISO/IEC 30107 (deployment mapping may vary by organization policy).

if_context in brief:
- Think of `if_context` as Rook's smart backpack: it keeps all the important notes safe and organized.
- When Rook needs to act, it only pulls the right few notes, not the whole library.

## What Rook Solves
Rook addresses three production risks:
1. Unprovable authorization paths for autonomous actions.
2. Weak linkage between execution and approved release context.
3. Failure-open behavior when controls degrade.

## Why Rook Is Distinct
Rook is governance-first by architecture:
- Policy-gated execution before side effects.
- Bounded context intelligence with provenance-aware retrieval.
- Replayable decision continuity with signed evidence orientation.
- Explicit treatment of non-findings and adversarial silence as governance signals.

## Long-Running Mission Design (Days/Weeks)
Rook is designed for long-running agent missions where context and controls must remain stable over time, not just in one chat turn.

Operational model:
- Full-fidelity history remains outside the prompt in append-only evidence stores.
- Active prompt context is budgeted and rebuilt from governed retrieval (`if_context`), not unlimited transcript replay.
- Mission continuity uses a conceptual trust flow (`stored` -> `used` -> `trusted`) governed by policy gates.
- If retrieval quality degrades or provenance is missing, execution path denies/defers (fail closed).

## if_context Specifics (External-Safe)
Key design specifics that make long-horizon behavior practical and auditable:
- Disclosure intent: these terms are included for due-diligence clarity, not as an implementation blueprint.
- `RML (Recursive Memory Learning)` continuity model: fold FSM + iterative viewpoint folding.
- RML scope note: this denotes governed memory lifecycle behavior and retrieval control, not unsupervised foundation-model retraining in production.
- Ledger-first memory model: artifacts + provenance first, prompt as bounded runtime view.
- Retrieval strategy: lexical retrieval is current production baseline; embedding retrieval is architecture-supported and can be policy-enabled when deployment evidence is attached.
- Provenance fields on retrieved snippets: source hash, timestamp, trust tier, and freshness.
- Isolation keys for retrieval scope (tenant/user/workspace boundary discipline).
- Redis can accelerate retrieval but is never the trust anchor; safe fallback is local index + ledger path.
- Operational memory lifecycle controls: `candidate`, `committed`, `tombstoned` with policy-controlled transitions.
- Lifecycle relation note: `stored/used/trusted` is conceptual governance framing; `candidate/committed/tombstoned` is the enforceable memory-state contract.

## if_context Messaging and Multi-Rook Coordination
Rook coordination is coupled to `if_context` state so multi-agent decisions remain replayable and policy-bound over long missions.

Coordination posture:
- Multi-Rook coordination uses `if_chat` as the real-time coordination plane and `if.blackboard` as the append-only task/signal authority.
- `if_context` carries the mission state and evidence pointers used by coordinating agents, so each handoff is reconstructable.
- SIP-like identity/session discipline is supported for coordination (`agent_id` stable, `sid` rotating) for interoperable call/session control patterns.
- Messaging transport metadata never overrides governance decisions; policy authority remains in `if.gov`/runtime gates.

Boundary:
- This pack claims SIP-like coordination identity/session discipline in architecture/deployment posture.
- This pack does not claim drop-in SIP telephony replacement or universal carrier/network interoperability.

## Core Runtime Control Path
1. Validate request and policy preconditions.
2. Verify principal and release proof context.
3. Record intent evidence.
4. Execute only if gates remain green.
5. Record result evidence and continuity anchors.
6. Verify chain/checkpoint continuity.

Fail rule:
- Any mandatory control failure results in deny/defer.

## Operator Gate Artifact Contract (Canonical PASS Shape)
Minimum PASS artifact fields for external review:
```json
{
  "gate_id": "rook-operator-gate",
  "evaluated_utc": "2026-02-16T02:27:37Z",
  "decision": "pass",
  "hard_fail_gates": [],
  "hard_fail_gate_codes": [],
  "principal_verification": "pass",
  "release_proof_verification": "pass",
  "chain_status": "pass",
  "anchor_status": "pass",
  "checkpoint_status": "pass",
  "evidence_refs": ["<receipt_or_pack_ref>"],
  "artifact_sha256": "<sha256>"
}
```

Hard-fail gate codes (canonical):
- `GATE.PROBE_HARD_FAIL`: any probe hard-fail gate present.
- `GATE.CHAIN_ANCHOR_CHECKPOINT_FAIL`: chain/anchor/checkpoint verification failure.
- `GATE.PRINCIPAL_FAIL`: principal verification failure.
- `GATE.RELEASE_PROOF_MISMATCH`: release-proof mismatch/failure.
- `GATE.MEDIA_PROOF_CAPSULE_MISSING`: missing deployment proof capsule when live media-factor authorization is claimed.
- `GATE.CLAIMS_LINT_FAIL`: external claim copy fails release claims-manifest lint.

Interpretation rule:
- If `hard_fail_gates` is non-empty, external compliance-grade claim usage is paused.

## Authorization Hardening Overlay
This is an additive overlay that reinforces existing enterprise authentication systems. It does not replace IdP/SSO/MFA.

Policy model:
- Organization policy profiles define required factors by risk tier, business context, and jurisdiction.

Reference tiering:
- `medium`: supervised voice challenge (or stronger per organization policy).
- `high`: hardware factor required plus one liveness signal.
- `critical`: hardware factor required plus two independent factors, plus governance approval gate.

Trust-anchor rule:
- Hardware factor is primary for high/critical approvals.
- Media-derived checks are supporting risk signals.
- Media-factor deployments must publish explicit capture/retention/access defaults (see data-handling section).

## Liveness Controls and Evidence Discipline
Liveness controls can be used where policy requires:
- Audio nonce challenge with dynamic prompt.
- Video liveness sequence challenge with randomized actions.
- Action-digest binding to prevent approval replay.

Evidence method (byte-verifiable):
- `challenge_nonce_sha256`
- `media_artifact_sha256` (if captured)
- `policy_profile_id`
- `policy_version`
- `decision_id`
- `expires_utc`
- verifier outcome code(s)
- final decision (`approve` / `defer` / `deny`)

Quality boundary:
- Voice/facial recognizer quality depends on each organization’s selected stack and operating conditions.
- Ambiguous outcomes must fail closed.

## Media-Factor Data Handling Boundary (Policy-Bound)
For deployments that enable media-factor authorization, external reviewers should request explicit handling terms:
- Default posture: raw media capture is disabled unless policy explicitly enables capture for a specific risk profile.
- Capture scope: challenge metadata is mandatory; raw media capture is policy-dependent and must be policy-tagged.
- Hash scope: challenge nonce, captured media artifacts (if any), and final decision tuple.
- Retention: time-bounded and policy-defined; no indefinite raw-media retention.
- Access: least-privilege access with auditable retrieval events and immutable access logs.
- Privacy/accessibility: consent and non-media fallback paths must follow organization policy.
- Audit expectation: policy-profile id and retention/access controls should be visible in runtime evidence records.
- If raw media retention is disabled, hash + decision evidence remains the verification anchor.

## Legacy Baseline Parity Boundary
This pack is explicit about scope so parity is not overstated.

Reviewed baseline extras (explicitly assessed, not ignored):
- multi-channel/session routing surfaces,
- session-to-session coordination tooling,
- background scheduling/wakeup patterns,
- companion node and voice interaction paths,
- browser/canvas and channel-specific automation layers.

Verified in current Rook scope:
- Governance-first autonomous execution with fail-closed controls.
- Long-running mission continuity via bounded retrieval + append-only evidence.
- Multi-agent/operator coordination surfaces via `if.blackboard` and `if_chat` (real-time coordination surface) in this deployment.
- SIP-like identity/session discipline is included in coordination design (`agent_id` stable, `sid` rotating).

Not claimed in this pack:
- Full parity with broad legacy omni-channel runtime surfaces (for example, every mobile voice/node/channel path).
- Universal parity for all legacy channel-specific automations and companion-app workflows.
- Any capability that lacks deployment evidence in this runtime.

## Black/White Status
Verified in this external pack:
- Governance-first architecture and claim-boundary discipline.
- Fail-closed control intent and evidence orientation.
- Authorization overlay is architecture-supported.
- Long-running mission control model is documented and deployment-scoped.
- if_context lifecycle framing is explicitly reconciled between conceptual and operational state models.
- Runtime claims-manifest lint gate is implemented and wired into operator-gate hard-fail semantics.

Not verified in this external pack:
- Universal biometric recognizer accuracy across vendor/model stacks.
- Deployment-specific live proof capsules for all media-factor auth paths.
- Compliance certification by an external auditor.
- Universal SIP carrier/network interoperability across all telecom environments.
- Organization-specific media retention/privacy/accessibility policy configuration in each deployment.

## Runtime Lockstep Update (IF-1820/IF-1823)
Implemented now (code and harness level):
- Manifest-validation path includes schema/validator caching for reduced hot-path latency.
- T0 perf harness now reports both `in_process` and `subprocess_cli` modes and evaluates thresholds against an explicit `target_mode`.
- Operator-gate artifact enforcement includes claims-manifest lint with deterministic hard-fail code `GATE.CLAIMS_LINT_FAIL`.
- Runtime deny-pack remains green for outbound tuple/channel negative paths.

Verification artifacts in this pack:
- `if_1820_t0_perf_harness_2026-02-16T102635Z.json`
- `if_1820_t0_deny_pack_2026-02-16T102749Z.json`
- `if_1820_claims_lint_safe_2026-02-16T102801Z.json`
- `if_1820_claims_lint_unsafe_2026-02-16T102801Z.json`
- `if_1820_operator_gate_safe_2026-02-16T102812Z.json`
- `if_1820_operator_gate_unsafe_2026-02-16T102812Z.json`
- `if_chat_bridge_single__2026-02-16T102820Z.json`
- `if_chat_bridge_multi__2026-02-16T102820Z.json`
- `if_chat_bridge_single_mcp_2026-02-16T103438Z.json`
- `if_chat_bridge_multi_mcp_2026-02-16T103439Z.json`
- `if_chat_mcp_health_2026-02-16T103438Z.md`
- `if_chat_ask_IF1823_2026-02-16T102837Z.json`
- `if_1820_implementation_verification_summary_2026-02-16T103100Z.md`
- `if_1820_runtime_smoke_2026-02-16T103300Z.md`

Performance black/white:
- Verified: hot runtime gate path (`target_mode=in_process`) is within threshold (`p95=0.523ms`, `p99=0.599ms`).
- Not claimed: subprocess cold-start latency meets threshold (`subprocess_cli p95=189.03ms`, `p99=217.432ms`).

### Evidence Excerpts + Hash Anchors (Outsider-Ready)
Minimal excerpts:
- `if_1820_operator_gate_safe_2026-02-16T102812Z.json`: `decision=pass`, `claims_lint_status=pass`, `hard_fail_gate_codes=[]`
- `if_1820_operator_gate_unsafe_2026-02-16T102812Z.json`: `decision=fail`, `claims_lint_status=fail`, `hard_fail_gate_codes=[GATE.CLAIMS_LINT_FAIL]`
- `if_1820_claims_lint_safe_2026-02-16T102801Z.json`: `ok=true`, `violations_count=0`
- `if_1820_claims_lint_unsafe_2026-02-16T102801Z.json`: `ok=false`, `violations_count=5`, first violation code=`FORBIDDEN_PHRASE`

SHA-256 anchors:
- `if_1820_operator_gate_safe_2026-02-16T102812Z.json`:
  `5c1dd3054ced610fe0476884e43b9534b3c95ce40c8c191f753a899e76e2db42`
- `if_1820_operator_gate_unsafe_2026-02-16T102812Z.json`:
  `080c28543fd6be10076b80d20e71eaaf8bb4be4742090bdd3b52c67bbcd8f331`
- `if_1820_claims_lint_safe_2026-02-16T102801Z.json`:
  `779418411b4d4109c56c68027fec1dd65a60d2128a5a99f90c8b450d6f7dfb54`
- `if_1820_claims_lint_unsafe_2026-02-16T102801Z.json`:
  `bbe3f0ace86bc7673ab157d4e435c59fda8d6559094db2f0035b71e05d91cd2d`

## External Evaluation Checklist
1. Request current gate pass/fail outputs.
2. Request chain/checkpoint continuity outputs.
3. Request proof capsule for any live media-factor claim.
4. Request policy-profile mapping by escalation tier.
5. Request fail-closed evidence for inconclusive auth factors.
6. Request multi-Rook coordination replay evidence (if_chat + if.blackboard + if_context linkage).
7. Request media-factor data-handling policy terms (capture, retention, access, fallback).
8. Request operator-gate claims lint evidence (`GATE.CLAIMS_LINT_FAIL` negative-path artifact).

## External Verifier Mini-Protocol (No Repo Dependency)
1. Obtain a published share reference and expected SHA-256 from the issuer.
2. Download hosted verifier and bundle payload:
```bash
curl -fL https://infrafabric.io/static/hosted/iftrace.py -o iftrace.py
curl -fL "https://infrafabric.io/static/dossier/<shareId>/download" -o emo_trace_payload_<trace_id>.tar.gz
```
3. Prepare isolated runtime for verifier dependencies:
```bash
python3 -m venv iftrace_venv
./iftrace_venv/bin/pip install canonicaljson pynacl
```
4. Verify payload integrity and provenance chain:
```bash
./iftrace_venv/bin/python iftrace.py verify --expected-sha256 <expected_sha256> emo_trace_payload_<trace_id>.tar.gz
```
5. Record result in black/white terms:
- Verified: bytes, manifest/hash integrity, signature/chain continuity.
- Not verified by receipts alone: semantic correctness, safety, legal/regulatory compliance.

No-CLI fallback:
- `https://infrafabric.io/static/hosted/iftrace.html`

## Verifier and Receipt-Schema Integrity Notes
For independent review without local repository access, external reviewers should request:
- Receipt schema identifier/version in every published receipt (`receipt_schema_version` or equivalent).
- Hosted verifier integrity metadata (`iftrace.py` SHA-256 and published verifier version).
- Verifier source inspectability (source file access and deterministic invocation).
- Schema compatibility policy (how long prior receipt versions remain verifiable).
- Verifier/scheme deprecation policy reference for lifecycle transparency.

Black/white:
- Verified when evidence is supplied: payload integrity, signature/chain continuity, and schema version used for verification.
- Not verified unless separately supplied: verifier supply-chain provenance attestations and long-term deprecation commitments.

## Open Controls Before Broader Live Claims
1. SIP/WebRTC auth-channel threat-model validation and controls.
2. SIP threat-model scope must cover both authorization-channel use and multi-agent coordination-plane use.
3. Liveness challenge rotation cadence.
4. Periodic red-team validation against current synthesis threats.
5. Standards-alignment mapping (or explicit documented exceptions).
6. Key-rotation automation and key-compromise runbook test evidence for broader procurement acceptance.

## Final Position
Rook is externally defensible as compliance-grade autonomous runtime governance.

Authorization hardening controls are policy-ready and architecture-supported; live enforcement claims remain deployment-evidence-bound.

## 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.

## Appendix A — Baseline Mapping (Operational, Not Certification)
This appendix describes operational control alignment for external due diligence. It is not a certification claim.

| Control objective | Rook mechanism | Evidence artifact hook | Boundary / Limitation |
|---|---|---|---|
| Prevent unauthorized side effects | Policy-gated execution before action | Operator-gate PASS artifact + runtime decision records | Legal/regulatory certification outcome |
| Bind action to actor identity | Principal verification in runtime control path | Principal verification status + decision evidence | Universal identity assurance level across all deployments |
| Bind action to approved software state | Release-proof verification before execute | Release-proof verification status + evidence refs | Full SDLC/certification attestation by external auditor |
| Preserve tamper-evident continuity | Chain/anchor/checkpoint verification | Chain/anchor/checkpoint pass outputs + artifact hash anchors | Proof of semantic correctness/safety from hash evidence alone |
| Fail closed on degraded controls | Mandatory gate deny/defer semantics | `hard_fail_gate_codes` and deny/defer decision traces | Zero false negatives in all operating conditions |
| Step-up human authorization for high risk | Policy-graded overlay with hardware-primary trust | Policy-profile mapping + media-factor proof capsules (when claimed live) | Universal biometric accuracy or universal telecom interoperability |
| Quantum-readiness posture | PQ receipt discipline on published artifacts (`if.trace` metadata) | Receipt metadata showing PQ signature profile when present | `QUANTUM READY` is not `quantum-secure`; deployment cryptographic proof is still required |

## Appendix B — Changelog (External Lineage)
- v2.1: claim-discipline pullback and architecture-support gating for unevidenced auth paths.
- v2.2: first pure external rewrite with internal scaffolding removed.
- v2.3: final external pack with full `if.trace` footer and explicit verification footer contract.
- v2.4: footer clarity update (inspectability note, connectivity-check labeling, and PQ receipt definition).
- v2.5: added long-running mission model, if_context specifics, legacy-baseline parity boundary, and concise if_context executive explanation.
- v2.6: added operational compliance-grade baseline, canonical operator-gate PASS artifact contract, media-factor data-handling boundary, outsider verifier mini-protocol, and procurement-facing key-management control note.
- v2.7: tightened SIP wording, standardized hard-fail gate codes, added verifier/schema integrity note, strengthened media data-handling defaults, and added operational baseline-mapping appendix.
- v2.8 (537 Pack): added runtime lockstep implementation evidence (claims-lint gate, validator caching, dual-mode perf harness, deny-pack refresh, and if_chat MCP health evidence).