# ORCHESTRATION MEGAPROMPT -- Evaluator Router

**Phase:** 7 -- orchestration-engineering-max
**Subsystem:** Evaluator (auditor-half)
**Scope:** Sequence 9 components (E1..E9) + 2 cross-cutting artifacts (Frame Registry, Evaluator Search Ledger) into an audit run. ZERO overlap with RAM runtime. Rooted in the Evaluator silo only.

---

## 1. Skill-Boundary Audit

Each component's interface surface -- owner, writers, readers, kill-gate behavior. This is what the router must respect.

### 1.1 E1 Isolation Verifier (PRIMARY KEYSTONE)

- **Owner:** E1 itself (pre-flight gate function).
- **Inputs:** Plugin manifests (RAM + Evaluator + peers); filesystem event stream; state-manager hooks; retrieval-call hooks.
- **Outputs:** Isolation Verification Report (PASS/FAIL), Circuit Breaker state (subsystem + global), per-axis verdicts.
- **Kill-gate behavior:** Failure on any of I1-I4 invariants HALTS all downstream Evaluator operation. Silent chaos success means verifier is broken -- also HALT.
- **Router dependency:** R1 runs E1 BEFORE any other skill. No clearance -> no pipeline.

### 1.2 E3 Frame Host

- **Owner:** E3 itself (parameterized slot).
- **Inputs:** `frame_id`, `ram_frame_id`, `question_id`, `question_intent`, `audit_target_artifact_ref`, optional `role_divider_acknowledgment`, optional `population_flag`.
- **Outputs:** `loaded_frame_handle` (with `.retrieve()` / `.score()` / `.terminate?()` / `.compat()`), `compatibility_declaration` (DISTINCT | PARTIAL), `role_divider_decision` (NOT_REQUIRED | REQUIRED_AND_PRESENT | REQUIRED_AND_MISSING_REFUSE), `chilisa_constraint_state`, Frame Registry write (as writer), Evaluator Search Ledger seed entry (as writer).
- **Kill-gate behavior:** NEEDS-INPUT on missing frame_id; REFUSE on unknown frame; STRUCTURAL_ERROR on malformed hooks; REQUIRED_AND_MISSING_REFUSE on realist_cmo x RAM_S03 without divider.
- **Router dependency:** R3 runs after E1 and E6. Router propagates any refusal as a hard halt.

### 1.3 E8 Frame Divergence Gate

- **Owner of:** Frame Registry (cross-cutting artifact).
- **Inputs:** `question_artifact`, `loaded_frame_handle`, `theta_q` (with `threshold_source` tag), `e1_cleared`, `error_rate_baseline`.
- **Outputs:** `gate_verdict` (PASS | FAIL | REFUSED) with `refusal_reason`; Frame Registry record (writes + seals); `abort_signal` (mid-run) on runtime convergence.
- **Kill-gate behavior:** REFUSED on MISSING_THETA / E1_NOT_CLEARED / FRAME_HOST_NOT_LOADED / RAM_FRAME_UNPARSEABLE / REGISTRY_WRITE_FAILURE. FAIL on Stage 1 overlap >= 2 OR Stage 2 D < theta_q. Runtime trip on any of five signals = abort.
- **Router dependency:** R4 runs after E3. Router holds `frame_pair_id` from seal and passes it downstream.

### 1.4 E2 Audit Method Engine

- **Owner:** Audit Artifact.
- **Inputs:** loaded frame + methodology pack handle (from E3), Frame Registry PASS verdict (from E8 seal), charter scope (from E6), Evaluator Search Ledger write handle (from E4), RAM output artifact (read-only).
- **Outputs:** Multi-level Audit Artifact (per-claim, per-source, per-methodology, cross-level tensions), `audit-query`/`audit-finding`/`audit-null`/`audit-refusal` ledger writes (as writer).
- **Kill-gate behavior:** Refuses on any precondition miss (Frame Registry missing, charter missing, ledger handle missing, RAM artifact malformed, E1 clearance missing).
- **Router dependency:** R5 runs after E8 PASS. 30% replication rate -> self-flags to E6 + E9.

### 1.5 E5 Blind-Spot Mapper

- **Inputs:** Charter criterion (pre-registered), E2 audit artifact, loaded frame, Frame Registry.
- **Outputs:** Findings record `{run_id, claim_id, probes_fired, signals_fired, severity_max, taxonomy_version, ledger_refs}` (to E7); diagnostic metadata co-emission `{probes_run_count, probes_fired_count, nulls_emitted, criterion_hash, taxonomy_version, delta_metrics}` (to E9); ledger writes (as writer).
- **Kill-gate behavior:** Signal 3 (criterion not pre-registered) -> HALT + CRITICAL to E6. Probe null-run is emitted, never silently dropped.
- **Router dependency:** R6 runs after E2; must emit to E4 AND E9 (co-emission prevents E5-x-E9 masking).

### 1.6 E4 Independent Scoring Layer

- **Owner of:** Evaluator Search Ledger (render authority).
- **Inputs:** E5 findings, E2 audit artifact, RAM confidence input, loaded frame identity + role-divider state, Ledger entries.
- **Outputs:** Scored Artifact (three axes with frame-prefixed formula IDs, three disagreement blocks at TOP, calibrated-silence stamps on zero-delta axes); Ledger render; emission metadata for E9.
- **Kill-gate behavior:** DP-1..DP-5 classified refusals. E-COLLAPSE / E-MIRROR / E-CEREMONIAL-DISAGREEMENT / E-HIDDEN-DISAGREEMENT / E-SILENT-NULL / E-LEDGER-LEAK / E-RAM-MATCH-PRESSURE / E-FRAME-IMPLICIT all fatal.
- **Router dependency:** R6 runs after E5; router structural-checks at R6 exit (axis-count == disagreement-block-count == 3; no composite field; every axis carries frame-prefixed formula ID).

### 1.7 E9 Self-Audit Resistance Monitor (SECONDARY KEYSTONE)

- **Inputs:** E5 output, E4 output, E7 history, RAM artifact (read-only for reference-groundedness check), Frame Registry (read-only), calibration-harness handle, inter-evaluator instance pool handle.
- **Outputs:** over-report signal, under-report signal, calibrated-silence report (5 required fields), ceremonial-pattern signal, calibration-harness record.
- **Kill-gate behavior:** BLOCK on missing input; BLOCK on indistinguishability pierced; ABORT on cadence-coupling violation; repair on forbidden-phrasing (positive-nothing-found as current affordance); MUST emit calibrated-silence with FIVE fields when silence applies.
- **Router dependency:** R7 runs after E4; BEFORE E7 so E7 can consume E9 signals. Router gates calibrated-silence emission here.

### 1.8 E6 Audit Charter Lock

- **Inputs:** Operator-submitted `proposed_charter`; cross-component messages from every other Evaluator skill; Isolation Verifier's inter-library content-overlap alarm.
- **Outputs:** `charter-locked` signal (with version + content hash + VICTORE declarations); 5-signal scope-creep verdicts (warning / halt / escalate-to-operator); `charter-amended` records.
- **Kill-gate behavior:** Refuses on incomplete / inconsistent charter; HALT on two concurrent signals; ESCALATE on signal 3 (stakeholder) or signal 4 (evidence-class) -- NON-OVERRIDABLE; HARD ERROR on ram-charter-content-leaked (re-triggers E1 Phase-5 isolation reopen).
- **Router dependency:** R2 runs after E1. E6 gates the audit pipeline; no charter -> no run.

### 1.9 E7 Reopen Authority Enforcer

- **Inputs:** E5 findings, E4 disagreement artifact, E9 four signal channels, reopen history from Ledger, Charter parameters (reopen ceiling, dwell-time, composite trigger spec, escalation receiver ID, thresholds), Frame Registry entry.
- **Outputs:** Exactly one binary verdict token: REOPEN | PASS | PASS-DEFERRED | ESCALATED; composite-evidence record; suppressed-ceremonial-reopen record; reopen-event log entry.
- **Kill-gate behavior:** EC-ADVISORY-REGRESSION / EC-GOODHART-DRIFT / EC-INPUT-MISSING / EC-CHARTER-MISSING / EC-ENFORCEMENT-SURFACE-DEGRADED / EC-CEREMONIAL-MASK / EC-OSCILLATION / EC-RUNTIME-SELF-CALIBRATION. All halt.
- **Router dependency:** R8 runs after E9. Router refuses to propagate any non-binary output.

### 1.10 Cross-cutting: Frame Registry

- **Owner:** E8.
- **Writers:** E3, E8.
- **Readers:** E2, E9, E7.
- **Path:** `state/evaluator/frame-registry/<run-id>/<question-id>.yaml`.
- **Schema:** per Phase 5 CROSS_CUTTING_ARTIFACTS Section 3.3; always includes `refinement_residue` (may be `[]`); sealed at audit close.
- **Router discipline:** router NEVER writes directly to the Frame Registry; only E3 and E8 may write. Router READS the record for the `isolation_verifier_clearance_id` back-reference check before final emission.

### 1.11 Cross-cutting: Evaluator Search Ledger

- **Owner:** E4 (render authority).
- **Writers:** E3 retrieval hooks, E2, E5.
- **Readers:** E4 (render), E7, E9.
- **Path:** `state/evaluator/evaluator-search-ledger/<run-id>/ledger.jsonl`.
- **Schema:** five record kinds (`audit-query`, `audit-finding`, `audit-null`, `audit-refusal`, `reopen-event`) -- DISJOINT from RAM's four record kinds.
- **Router discipline:** router may write `record_kind = router-intake` seed entries (functional alias within `audit-refusal` schema family) at R0 when E4 has published the ledger handle. Otherwise the router waits for E4's ledger-open event and issues its seed via E4.

---

## 2. Active Working Set (per-run frame loading)

### 2.1 Run-scoped state

Per audit run, the router holds:

```
run_state := {
  run_id: UUID,
  command: "/eval-audit" | "/eval-charter" | "/eval-abort",
  ram_output_path: string (/eval-audit only),
  charter_path: string (/eval-charter only; then later referenced by /eval-audit),
  target_ram_run_id: string,
  isolation_verifier_clearance_id: string | null,  // set at R1
  charter_version: int | null,                     // set at R2
  charter_hash: string | null,                     // set at R2
  questions: [                                     // one or more question binds
    {
      question_id: UUID,
      question_intent: string,
      frame_id: string,
      ram_frame_id: string,
      theta_q: float,
      role_divider_acknowledgment: token | null,
      population_flag: bool,
      loaded_frame_handle: handle | null,           // set at R3
      frame_pair_id: UUID | null,                   // set at R4 PASS
      compatibility_declaration: obj | null,        // set at R3
      role_divider_decision: enum | null,           // set at R3
      audit_artifact_ref: ref | null,               // set at R5
      blind_spot_findings_ref: ref | null,          // set at R6
      scored_artifact_ref: ref | null,              // set at R6
      e9_signals_refs: obj | null,                  // set at R7
      verdict_token: enum | null,                   // set at R8
      composite_evidence_record_ref: ref | null,    // set at R8
    }
  ],
  refusal_state: null | { phase, reason, written_to_ledger: bool }
}
```

### 2.2 Which frame loads for which question class

Frame selection authority is the operator's (via charter declaration). The router does not select. However, the router enforces that the charter declares `frame_id` per question AND that the declaration honors the Chilisa constraint when `population_flag` fires.

Full mapping lives in `FRAME_LOADING_RULES.md`.

### 2.3 Role-divider binding-time enforcement

When (`frame_id == realist_cmo` AND `ram_frame_id == RAM_S03`) for any question in the run:

1. Router checks for `role_divider_acknowledgment` at R0 intake.
2. Router passes token to E3 at R3.
3. E3 runs its two-clause parser (audit-criterion-only + NOT transportability-signal-reuse).
4. E3 returns `role_divider_decision`. Three possible values propagate:
   - `NOT_REQUIRED` -- proceed.
   - `REQUIRED_AND_PRESENT` -- proceed with Frame Registry record noting acknowledgment.
   - `REQUIRED_AND_MISSING_REFUSE` -- router HALTs; writes `audit-refusal` with `refusal_reason = ROLE_DIVIDER_BREACH`; surfaces to operator.

---

## 3. Coordinator Logic (phase-by-phase narrative)

### 3.1 R0 Intake

Parse command. Generate or receive `run_id`. Attempt to write router-intake seed entry to the Evaluator Search Ledger. If the Ledger does not exist yet for this `run_id`, defer the seed write until E4's ledger-open at R6; record deferral.

Decision points:
- Command = `/eval-audit`: validate `<ram-output-path>` resolves to a readable artifact via `bridge/ram-to-evaluator-handoff/`. If not, HALT with `EC-INPUT-MISSING`.
- Command = `/eval-charter`: validate `<charter-path>` resolves to a readable charter envelope. If not, HALT with `EC-INPUT-MISSING`.
- Command = `/eval-abort`: proceed directly to abort path (R-ABORT below).

### 3.2 R-ABORT (for /eval-abort)

1. Look up in-flight `run_id`. If none exists OR run already sealed, return operator-facing notice and exit.
2. Write `audit-refusal` record with `refusal_reason = OPERATOR_ABORT` via E4 render authority.
3. Request E8 to seal the Frame Registry record if one exists for this run.
4. Emit abort acknowledgement to operator; no bridge handoff.
5. Exit.

### 3.3 R1 Isolation Verifier pre-flight HALT gate (MANDATORY)

1. Invoke `isolation-verifier` with the standard envelope: {RAM manifest, Evaluator manifest, peer manifests, state snapshots for both silos, retrieval-capability catalog, runtime tick handle}.
2. Expect an Isolation Verification Report per template. Required content: Phase A (boundary declaration), Phase B (baseline capture), Phase C (continuous invariant log excerpt), Phase D (violation records, if any), Phase E (chaos experiment results), Phase F (lock-down state), Phase G (final PASS/FAIL verdict with per-axis breakdown).
3. Acceptance rule: verdict == PASS AND all four invariants (I1 path, I2 state-namespace, I3 retrieval-surface, I4 library-content Merkle) == PASS AND no global Circuit Breaker open AND chaos-experiment trap rate == 100%. Anything else -> FAIL.
4. Record `isolation_verifier_clearance_id` (report UUID) for back-reference through the run.
5. On FAIL: HALT the run. Write the failure to the Ledger via a deferred E4 seed (or hold until E4 starts). Surface the report to the operator. Never proceed.

### 3.4 R2 Audit Charter Lock (MANDATORY)

For `/eval-audit`: the operator must have previously run `/eval-charter` AND the resulting charter must cover this `target_ram_run_id`. The router reads the locked charter version from `state/evaluator/charters/<target_ram_run_id>/locked.json` (path lives inside Evaluator silo; no RAM access).

For `/eval-charter`: E6 is invoked now to produce the lock.

1. Invoke `audit-charter-lock` with the appropriate envelope. For audit: pass `{audit_id, target_ram_run_id}`; E6 returns the currently-locked charter. For charter event: pass `{proposed_charter}`.
2. E6 runs Phase A (intake + validate). Returns charter-locked OR refusal code.
3. On refusal (`charter-intake-incomplete` / `charter-intake-inconsistent` / `victore-dimension-missing` / `ram-charter-content-leaked-into-audit-charter`): HALT. Write refusal. For ram-charter-leak: notify E1 for an isolation re-review (inter-library content-overlap alarm).
4. On `charter-locked`: record `charter_version` + `charter_hash` + scope spec + stakeholders.
5. For `/eval-charter`: return `charter-locked` record to operator and exit.

### 3.5 R3 Frame Host binding

For each question in the charter:

1. Extract per-question inputs: `frame_id`, `ram_frame_id`, `question_id`, `question_intent`, `audit_target_artifact_ref`, optional `role_divider_acknowledgment`, optional `population_flag`.
2. Invoke `frame-host` with the envelope.
3. E3 runs Phase 1..6: Registry intake, selection verification, hook loading, compatibility declaration (LOAD-BEARING), role-divider check (LOAD-BEARING), instantiation + registry write.
4. Router receives: `loaded_frame_handle`, `compatibility_declaration`, `role_divider_decision`, `chilisa_constraint_state`, Frame Registry write confirmation, Evaluator Search Ledger seed confirmation.
5. Propagation rules:
   - `role_divider_decision == REQUIRED_AND_MISSING_REFUSE` -> HALT, write refusal, surface to operator (action: supply token or change frame).
   - Unknown frame / missing frame_id / missing ram_frame_id / malformed hook -> HALT, write refusal, surface to operator.
   - All clean -> store state, proceed.

### 3.6 R4 Frame Divergence Gate (pre-run)

For each question:

1. Invoke `frame-divergence-gate` with: `{question_artifact, loaded_frame_handle, theta_q, e1_cleared: true, error_rate_baseline}`.
2. E8 runs Step 1..7: precondition checks, theta_q resolution, Stage 1 binary structural, Stage 2 thresholded D, combine verdicts, Frame Registry write, gate emission.
3. Receive: `gate_verdict` and, on PASS, `frame_pair_id`.
4. Propagation rules:
   - `PASS` -> record `frame_pair_id`; proceed.
   - `FAIL` -> HALT, write refusal, record stage-level failure codes; surface to operator (action: change frame selection OR supply a different theta_q in charter).
   - `REFUSED` -> HALT, write refusal, surface reason (MISSING_THETA / E1_NOT_CLEARED / FRAME_HOST_NOT_LOADED / RAM_FRAME_UNPARSEABLE / REGISTRY_WRITE_FAILURE).
5. E8 continues runtime convergence monitoring in the background from this point forward. The router registers a callback to receive `abort_signal` events (see R7.4).

### 3.7 R5 Audit Method Engine

1. Invoke `audit-method-engine` with loaded frame handle, Frame Registry `frame_pair_id`, charter scope, `isolation_verifier_clearance_id`.
2. E2 checks its own Invocation Preconditions (HARD GATE). Any precondition miss -> E2 writes `audit-refusal` and halts. Router receives the refusal and propagates.
3. E2 runs Phase A..F.
4. Receive: Audit Artifact reference, ledger-write confirmations.
5. Monitor: if E2 triggers the 30%-replication-rate consultation, the router forwards this signal to E6 (scope-creep consideration) and to E9 (ceremonial-pattern candidate).

### 3.8 R6 Blind-Spot Mapper + Independent Scoring Layer

Two sequential invocations:

**R6a: Blind-Spot Mapper (E5)**

1. Invoke `blind-spot-mapper` with charter criterion, E2 audit artifact, loaded frame, Frame Registry.
2. E5 runs Phase A..F: pre-registered criterion intake (GATE), RAM-output intake, six probes (fixed order), 5-signal integrity check, taxonomy update, findings output.
3. Receive: findings record (for E7), diagnostic metadata (for E9), ledger-write confirmations.
4. Halt path: if E5 fires Signal 3 (criterion missing/ambiguous), HALT and return CRITICAL to E6 for charter amendment.

**R6b: Independent Scoring Layer (E4)**

1. Invoke `independent-scoring-layer` with E5 findings, E2 audit artifact, RAM confidence input, loaded frame identity + role-divider state, Ledger entries.
2. E4 runs Phase A..G: intake, formula instantiation, three-axis computation in isolation per axis, RAM-confidence comparison per axis, disagreement rendering at TOP, ledger render with zero-overlap verification, emission.
3. Receive: Scored Artifact with three disagreement blocks at top, emission metadata for E9.

**Router structural check at R6 exit:**

- `axis_count == disagreement_block_count == 3` -- verify.
- No composite / overall / integrated / holistic field present -- scan emission schema.
- Every axis carries a frame-prefixed formula ID (PRAG / PHEN / CONSTR / REAL-AC / HIST / DISC / CHILISA) -- verify. A RAM-prefix formula ID is an E-MIRROR fatal.
- Ledger render shows zero-overlap vs RAM's Search Ledger -- verify via E4's Phase F check.

On any failure -> HALT with the matching error class (E-COLLAPSE / E-MIRROR / E-FRAME-IMPLICIT / E-LEDGER-LEAK).

### 3.9 R7 Self-Audit Resistance Monitor + runtime convergence concurrent check

**R7a: E9 invocation**

1. Invoke `self-audit-resistance-monitor` with E5 output, E4 output, E7 history (empty for first cycle), RAM artifact (read-only reference), Frame Registry (read-only), calibration-harness handle (if scheduled), inter-evaluator instance pool handle.
2. E9 runs Step 1..8: watch-surface setup, over-report detection (three affordances), under-report detection (two affordances + eval-awareness), calibration run (if scheduled), calibrated-silence emission (if silence applies), anti-deviation self-check, emit signals, cross-audit pattern tracking.
3. Receive: `{over_report_signal?, under_report_signal?, calibrated_silence_report?, ceremonial_pattern_signal?, calibration_harness_record?}`.

**R7b: Calibrated-silence emission gating (router enforcement)**

If E5 found no probe fires AND E4 shows zero-delta on one or more axes, E9 MUST emit a `calibrated_silence_report` covering those surfaces. Required fields:

1. Bounded surface S (explicit watch-surface list).
2. Seeded catch rate R (from fresh indistinguishability-passing calibration; per-class).
3. Equivalence-test result (TOST against pre-registered tolerance band).
4. Residual ceremonial-risk note (explicit statement of what is OUTSIDE S and unobserved).
5. Taxonomy-completeness disclaimer (Metaxa et al. 2021 grounding).

If the report is missing OR lacks any field OR contains "positive-nothing-found" as a current affordance -> HALT. Repair via E9 re-invocation OR emit missing-input signal from E9.

**R7c: Runtime convergence concurrent check**

E8 has been running runtime detectors since R4. If an `abort_signal` has arrived during R5/R6/R7:

1. HALT the current pipeline position.
2. Record the abort in the Frame Registry runtime_log (E8 does this).
3. Flip `overall_verdict` on the Frame Registry record to `REFUSE` (per Phase 5 lifecycle rule 3 on E8).
4. Jump to R8 to let E7 handle the abort via its convergence-failure internal mode.

### 3.10 R8 Reopen Authority Enforcer

1. Invoke `reopen-authority-enforcer` with E5 findings, E4 disagreement artifact, E9 four signal channels, reopen history from Ledger, Charter parameters, Frame Registry entry for this question.
2. E7 runs Phase 0..7: pre-flight, trigger intake, ceremonial-reopen detection, composite-trigger evaluation, dwell-time gate, bounded-count gate, oscillation/convergence-failure handling, enforcement-surface handoff.
3. Receive: exactly one verdict token from {REOPEN, PASS, PASS-DEFERRED, ESCALATED}. Plus composite-evidence record.

**Router refusal checks:**

- If verdict is not in the four-token set -> HALT with `EC-ADVISORY-REGRESSION`.
- If verdict is REOPEN and the composite-evidence record is missing -> HALT with `EC-GOODHART-DRIFT`.
- If verdict is PASS while E9 emitted an active ceremonial-pattern signal AND E7's output lacks the suppression record -> HALT with `EC-CEREMONIAL-MASK`.
- If verdict is PASS while findings surface carried silence but no calibrated-silence report accompanies -> HALT (silence must be calibrated).

### 3.11 R9 Enforcement-surface handoff + ledger seal

1. Package the final output bundle:
   ```
   eval_handoff := {
     verdict_token,                               // binary
     composite_evidence_record,                   // from E7
     scored_artifact,                             // from E4
     blind_spot_findings,                         // from E5
     e9_signals,                                  // from E9
     frame_registry_entry_ref,                    // from E8
     isolation_verifier_clearance_id,             // from E1 at R1
     audit_artifact_ref,                          // from E2
     ledger_provenance_hash,                      // from E4 render
     run_id, question_id, target_ram_run_id,
     charter_version, charter_hash
   }
   ```
2. Emit to the top-level loop:
   - For REOPEN or ESCALATED: write to `bridge/evaluator-to-ram-reopen/<run-id>.json`. The top-level loop picks this up and decides rerun enforcement.
   - For PASS or PASS-DEFERRED: write to the same bridge file with verdict-token semantics; top-level loop consumes and seals the cycle.
3. Write the final `reopen-event` record to the Evaluator Search Ledger (via E4 render authority).
4. Request E8 to seal the Frame Registry record (`sealed_at = now-ISO8601`).
5. Receive acknowledgement-only response. If a richer reply channel is detected -- RAM attempting veto / advisory narrative / substantive reply -> HALT with `EC-ENFORCEMENT-SURFACE-DEGRADED`.
6. Run complete.

---

## 4. Cross-cutting write discipline (at orchestration level)

### 4.1 Frame Registry

- Owner: E8. Writers: {E3, E8}. Readers: {E2, E9, E7}.
- Path: `state/evaluator/frame-registry/<run-id>/<question-id>.yaml`.
- The router never writes directly. The router verifies writes happened (E3 at R3; E8 at R4 and R9).
- The router enforces that every downstream write references `isolation_verifier_clearance_id`. Failure to reference == contract violation.
- `refinement_residue` is ALWAYS present in the record; may be `[]`. Router structural-checks at R9 exit.
- Record is sealed at R9; post-seal writes are blocked by E8.

### 4.2 Evaluator Search Ledger

- Owner: E4 (render). Writers: {E3 retrieval hooks, E2, E5}. Readers: {E4, E7, E9}.
- Path: `state/evaluator/evaluator-search-ledger/<run-id>/ledger.jsonl`.
- Five record kinds (audit-query, audit-finding, audit-null, audit-refusal, reopen-event) -- DISJOINT from RAM's four record kinds (every-query, every-accepted, every-rejected, every-skipped).
- The router may write `audit-refusal` records at R0/R1/R2/R3/R4/R6/R7/R8 halt paths ONLY through E4's handle (router does not write direct JSONL; it requests the entry through E4 or E4's delegate).
- The router verifies zero-overlap vs RAM's Search Ledger at R6 (E4 Phase F) and again at R9 (sealing).
- Schema deliberately disjoint; if any record-kind field collides with RAM's schema, the router receives the alarm and HALTs for isolation re-review.

### 4.3 Writer routing summary

| Phase | Writer skill | Artifact | Record kinds |
|---|---|---|---|
| R1 | E1 | Isolation Verification Report (private to E1 but referenced everywhere) | n/a |
| R2 | E6 | charter envelope (locked.json under Evaluator silo) | n/a |
| R3 | E3 | Frame Registry (initial bind fields), Evaluator Search Ledger (seed `audit-query`) | audit-query |
| R4 | E8 | Frame Registry (divergence_report + seal pending) | n/a |
| R5 | E2 | Evaluator Search Ledger (`audit-query`, `audit-finding`, `audit-null`, `audit-refusal`) | 4 |
| R6a | E5 | Evaluator Search Ledger (`audit-query`, `audit-finding`, `audit-null`, `audit-refusal`) | 4 |
| R6b | E4 | Evaluator Search Ledger (render snapshot; reopen-event later) | render |
| R7 | E9 | (does not write to ledger directly; emits signals consumed by E7) | n/a |
| R8 | E7 | Evaluator Search Ledger (`reopen-event` via E4 render authority) | reopen-event |
| R9 | E8 | Frame Registry (seal) | seal |

---

## 5. Isolation Verifier pre-flight HALT gate (detailed contract)

E1 is the primary keystone and the HALT gate that every Evaluator run begins with.

### 5.1 Invocation envelope (from router)

```
isolation_verifier_invocation := {
  run_id,
  ram_manifest_path: "ram/manifest.json",
  evaluator_manifest_path: "evaluator/manifest.json",
  peer_manifests: [...],
  ram_state_snapshot: "state/ram/*" (read-only metadata for integrity check; NO content read),
  evaluator_state_snapshot: "state/evaluator/*",
  retrieval_capability_catalog,
  tick_handle,
  tick_cadence: "every-skill-invocation + every-state-mutation + periodic Merkle recompute"
}
```

### 5.2 Acceptance rule

PASS iff ALL of the following are true:

1. Report verdict == PASS.
2. All four invariants (I1 path, I2 state-namespace, I3 retrieval-surface, I4 library-content Merkle) == PASS.
3. No global Circuit Breaker is open.
4. Chaos experiment trap rate observed in Phase E == 100% (no silent success).
5. Cross-cutting artifact schema-distinctness check passed (Frame Registry vs any RAM analog; Evaluator Search Ledger vs RAM Search Ledger).

If ANY of the above is false: FAIL. HALT the run. No downstream skill runs.

### 5.3 Clearance ID propagation

On PASS, E1 emits a unique `isolation_verifier_clearance_id`. The router records it and ensures every subsequent Frame Registry record and every ledger write includes this ID as a back-reference. A missing back-reference at R9 is a contract violation.

### 5.4 Why pre-flight (and not background-only)

Per Phase 2B E1 and Phase 4 E1 SKILL.md: build-time AND continuous runtime. The router's use of E1 is not a substitute for E1's continuous runtime detectors -- those run through the entire audit cycle. The pre-flight invocation is the structural gate that ensures the run is allowed to start; the runtime detectors catch drift mid-run.

---

## 6. Calibrated-silence emission gating

Calibrated silence replaces the retired "positive-nothing-found" affordance. E9 is the only skill authorized to emit calibrated silence. The router gates emission through E9.

### 6.1 Trigger condition

Calibrated silence applies when:

- E5 found no probe fires across all six probes AND no signals fired OR
- E4 computed zero-delta on one or more axes OR
- E7 is about to emit PASS and the downstream artifact will contain apparent-silence surfaces.

### 6.2 Router-enforced five-field requirement

Every calibrated-silence report MUST carry:

1. **Bounded surface S** -- explicit list of what was scanned (probes run, signals evaluated, axes computed, claims surveyed).
2. **Seeded catch rate R** -- per-class catch rate from a FRESH indistinguishability-passing calibration record.
3. **Equivalence-test result** -- TOST (Lakens 2016) result against pre-registered tolerance band.
4. **Residual ceremonial-risk note** -- explicit statement of what is OUTSIDE S and therefore unobserved.
5. **Taxonomy-completeness disclaimer** -- Metaxa et al. 2021 grounding (the taxonomy only calibrates against defect classes it imagines).

### 6.3 Router refusal conditions

- Silence emission present without any of the five fields -> HALT; E9 re-invoked or missing-input signal emitted.
- Emission contains the phrase "positive-nothing-found" as a current affordance -> HALT (forbidden phrasing); E9 repairs to bounded-surface-S framing.
- Calibration harness handle distinguishable from real RAM input -> E9 aborts calibration; router propagates as missing-input.
- Reporting surface for calibrated silence is NOT structurally identical to the reporting surface for findings -> HALT with architectural-failure signal (reporting-surface parity requirement).

### 6.4 Why this gate at the router level

Per E9 Mission-Critical Constraints: silence without bounded surface S is FAILURE in open-domain research audit (no computable Completeness Threshold; Clarke et al. 2004). The router enforces this as a structural check because downstream consumers (top-level loop, operator) cannot verify completeness post-hoc. If silence ships without the five fields, the dual-system's honesty claim collapses.

---

## 7. Five-property implementation map

The Phase 2 implementation plan requires the router to realize five Evaluator properties. Each is mapped to an orchestration-level mechanism:

| Property | Mechanism at orchestration level |
|---|---|
| 1. Independent retrieval (different search strategy than RAM) | Frame Host's retrieval hooks are frame-specific (Section 2.3 of E3 SKILL.md). Router never permits any retrieval path that reads RAM's Search Ledger state or RAM's retrieval surfaces. Evaluator Search Ledger lives in a disjoint path with disjoint record kinds. E1 runtime I3 invariant continuously verifies. |
| 2. Claim-support adjudication (per-claim, per-source) | E2 Audit Method Engine runs three non-substitutable levels per audit question (D.1 per-claim, D.2 per-source, D.3 per-methodology). Router enforces that all three levels appear in the Audit Artifact. Findings cite a frame-criterion ID plus the RAM-artifact element. |
| 3. Blind-spot mapping against RAM's method selection and frame | E5 Blind-Spot Mapper runs six frame-level defect probes (monoculture, covert tier-bias, forced closure, pub-bias miss, retraction miss, AI-contamination miss) plus the 5-signal integrity inventory. Probes operate under the loaded Evaluator frame, so findings are expressed in an epistemology RAM did not use. |
| 4. Three-axis confidence (separate scores, separate reasoning) | E4 Independent Scoring Layer computes Evidence-Independent / Transportability-Independent / Decision-Independent in isolation per axis. Router structural-checks at R6 exit that axis_count == disagreement_block_count == 3 and that no composite field exists. Formula IDs carry frame prefix (never RAM-prefix). |
| 5. Reopen trigger (Evaluator surfaces material RAM missed -> RAM reopens automatically) | E7 Reopen Authority Enforcer emits exactly one of four binary verdict tokens. REOPEN is architecturally enforced via the enforcement-surface contract to the top-level loop; RAM has no veto channel. Router halts on any advisory regression. |

---

## 8. Error class registry (router-level)

| Error class | Origin | Router action |
|---|---|---|
| `EC-ROUTER-CONTRACT-VIOLATION` | Internal -- router did something it should not | HALT; write to Ledger; escalate to evaluator-engineering-max |
| `EC-ISOLATION-FAIL` | E1 R1 | HALT; refuse run; do not proceed past R1 |
| `EC-CHARTER-LOCK-FAIL` | E6 R2 | HALT; refuse run; surface to operator |
| `EC-ROLE-DIVIDER-BREACH` | E3 R3 | HALT; refuse run; require token or frame change |
| `EC-GATE-REFUSED` / `EC-GATE-FAILED` | E8 R4 | HALT; refuse run; surface stage-level reason |
| `EC-COLLAPSE-DETECTED` | R6 exit structural check | HALT; return to E4 for re-render |
| `EC-MIRROR-DETECTED` | R6 exit structural check | HALT; re-instantiate formulas from Frame Host |
| `EC-LEDGER-LEAK` | R6 exit / R9 | HALT; Isolation Verifier re-review |
| `EC-ADVISORY-REGRESSION` | R8 verdict check | HALT; E7 re-emit with binary token |
| `EC-GOODHART-DRIFT` | R8 verdict check | HALT; E7 re-evaluate composite |
| `EC-CEREMONIAL-MASK` | R8 verdict check | HALT; E7 must emit suppression record |
| `EC-ENFORCEMENT-SURFACE-DEGRADED` | R9 handoff | HALT; architectural defect; raise to top-level loop |
| `EC-RUNTIME-SELF-CALIBRATION` | Any phase | HALT; reject change; notify E9 |
| `EC-INPUT-MISSING` | R0..R9 (any) | HALT; surface to operator |
| `EC-SILENCE-UNCALIBRATED` | R7 gating | HALT; re-invoke E9 |

---

## 9. Discipline invariants (router checks before every phase exit)

- Double hyphens throughout all output text.
- Every Ledger write for this run carries `isolation_verifier_clearance_id`.
- Every Frame Registry write for this run carries `isolation_verifier_clearance_id`.
- No router-written content crosses into `state/ram/*` or `ram/` library paths.
- No output contains "positive-nothing-found" as a current affordance.
- Verdict token at R8 is exactly one of {REOPEN, PASS, PASS-DEFERRED, ESCALATED}.
- Axis-count == disagreement-block-count == 3 at R6 exit.
- Calibrated-silence report carries all five required fields at R7 exit.
- Three-axis scored artifact has no composite / overall / integrated / holistic field.
- Frame Registry `refinement_residue` is present (may be `[]`).
- Bridge handoff at R9 receives acknowledgement-only; any richer reply = architectural defect.

**End of ORCHESTRATION_MEGAPROMPT.md.**
