clearotron 0.4.0 → 0.4.1-beta.0

package/driver/contract-vocabulary.mjs

@@ -80,7 +80,7 @@ export const VOCABULARY = [
   { token: "connotation_search_missing", stages: ["common-law"], site: "driver/verify.mjs" },
   { token: "receipts_short", stages: ["common-law"], site: "driver/verify.mjs" },
   { token: "half_path_unrecognized", stages: ["common-law-half"], site: "driver/verify.mjs:395" },
-  { token: "no_coverage_status_row", stages: [...CL, "register-digest"], site: "driver/verify.mjs:452, 1416" },
+  { token: "no_coverage_status_row", stages: [...CL, "register-digest"], site: "driver/verify.mjs:452 commonLawMeaningSeat, 1416" },
   // B — `connotation_form_unparseable` and `connotation_form_untouched` are GONE: they
   // were states only a hand-authored document could be in, and the form path is deleted (ruling
   // 2026-08-17). Their subject matter is carried by the call tokens under the D1 family row below.
@@ -139,7 +139,7 @@ export const VOCABULARY = [
   { token: "coverage_no_status", stages: ["register-digest"], site: "driver/verify.mjs" },
   { token: "coverage_form_missing", stages: ["register-digest"], site: "driver/verify.mjs" },
   { token: "coverage_form_empty", stages: ["register-digest"], site: "driver/verify.mjs" },
-  { token: "coverage_status_offenum", stages: ["register-digest"], site: "driver/verify.mjs:2050" },
+  { token: "coverage_status_offenum", stages: ["register-digest"], site: "driver/verify.mjs validators.registerFindings" },
   { token: "coverage_deferred_unaccounted", stages: ["register-digest"], site: "driver/verify.mjs coverageFormFail", family: "driver/register-plan.mjs PROVIDER_HARD_ERROR_PREFIX — token on a data row", dynamic: "D5" },
   { token: "coverage_clean_unexecuted", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs validatePlanFeasibility", dynamic: "D6" },
   { token: "coverage_clean_skipped", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs searchedJurisdictionsFromPlan", dynamic: "D6" },
@@ -150,7 +150,7 @@ export const VOCABULARY = [
   { token: "coverage_axis_", stages: ["register-digest"], site: "driver/verify.mjs", family: "driver/coverage-ledger.mjs", dynamic: "D4" },
   { token: "coverage_status_invalid", stages: ["register-digest"], site: "driver/verify.mjs", family: "driver/coverage-ledger.mjs", dynamic: "D4" },
   { token: "coverage_classes_invalid", stages: ["register-digest"], site: "driver/verify.mjs", family: "driver/coverage-ledger.mjs", dynamic: "D4" },
-  { token: "plan_execution_unreadable", stages: ["register-digest", "narrative-refutation"], site: "driver/verify.mjs:1496, 1712" },
+  { token: "plan_execution_unreadable", stages: ["register-digest", "narrative-refutation"], site: "driver/verify.mjs:1496 rowLabel, 1712" },
 
   // ── matter-frame / clearance-variants / blind-frame / frame-diff ──────────────────────────────────────
   { token: "stagecontracts_invalid", stages: ["matter-frame", "clearance-variants", "placement-inquiry", "case-law"], site: "driver/verify.mjs:1539 coverageEntryList, 1170, 1366, 1677" },
@@ -197,7 +197,7 @@ export const VOCABULARY = [
   // verify.mjs reaches the module, so a family that could grow a member no row covers must be readable.
   { token: "matterframe_", stages: ["matter-frame"], site: "driver/matter-frame-record.mjs acceptMatterFrame", family: "driver/matter-frame-record.mjs", dynamic: "D3" },
   { token: "framediff_model_missing", stages: ["frame-diff"], site: "driver/verify.mjs" },
-  { token: "framediff_", stages: ["frame-diff"], site: "driver/verify.mjs:1224 → 742", family: "driver/frame-diff-model.mjs", dynamic: "D3" },
+  { token: "framediff_", stages: ["frame-diff"], site: "driver/verify.mjs:1224 checkFindingsSibling → 742", family: "driver/frame-diff-model.mjs", dynamic: "D3" },
 
   // ── register-unit ──────────────────────────────────────────────────────────────────────────────────
   { token: "declared_not_executed", stages: ["register-unit"], site: "driver/verify.mjs" },
@@ -206,17 +206,17 @@ export const VOCABULARY = [
   { token: "named_band_invalid", stages: ["register-unit"], site: "driver/verify.mjs" },
   { token: "named_band_collapsed", stages: ["register-unit"], site: "driver/verify.mjs" },
   { token: "band_block_unplanned", stages: ["register-unit"], site: "driver/verify.mjs" },
-  { token: "named_band_", stages: ["register-unit"], site: "driver/verify.mjs:1736 → 742", family: "driver/named-band.mjs", dynamic: "D3" },
+  { token: "named_band_", stages: ["register-unit"], site: "driver/verify.mjs validators.registerUnit", family: "driver/named-band.mjs", dynamic: "D3" },
 
   // ── placement-inquiry ──────────────────────────────────────────────────────────────────────────────
-  { token: "placementmodel_missing", stages: ["placement-inquiry"], site: "driver/verify.mjs:1352, 1379" },
+  { token: "placementmodel_missing", stages: ["placement-inquiry"], site: "driver/verify.mjs:1352 connotationViolations, 1379" },
   { token: "placement_unjudged", stages: ["placement-inquiry"], site: "driver/verify.mjs placementAccountVerdict" },
   { token: "placement_register_unrendered", stages: ["placement-inquiry"], site: "driver/verify.mjs placementAccountVerdict" },
   { token: "placement_form_unreadable", stages: ["placement-inquiry"], site: "driver/verify.mjs placementAccountVerdict" },
-  { token: "placement", stages: ["placement-inquiry"], site: "driver/verify.mjs:1352 → 742", family: "driver/placement-model.mjs (`placement_*` and `placements_*`)", dynamic: "D3" },
+  { token: "placement", stages: ["placement-inquiry"], site: "driver/verify.mjs:1352 connotationViolations → 742", family: "driver/placement-model.mjs (`placement_*` and `placements_*`)", dynamic: "D3" },
 
   // ── case-law / narrative-refutation ────────────────────────────────────────────────────────────────
-  { token: "caselaw_ledger_missing", stages: ["case-law"], site: "driver/verify.mjs:1682, 1685" },
+  { token: "caselaw_ledger_missing", stages: ["case-law"], site: "driver/verify.mjs validators.caseLaw" },
   { token: "caselaw_ledger_unparseable", stages: ["case-law"], site: "driver/verify.mjs" },
   { token: "caselaw_ledger", stages: ["case-law"], site: "driver/verify.mjs:2425 caseLawLedgerFail", family: "driver/case-law-ledger.mjs caseLawLedgerFail (census reasons)", dynamic: "D8" },
   { token: "no_verdict_line", stages: ["narrative-refutation"], site: "driver/verify.mjs" },
@@ -234,8 +234,8 @@ export const VOCABULARY = [
 /**
  * WRAPPERS — the emitted failure string is not always the bare token.
  *
- *   invalid_file:<rel(gradedArtifact)>:<validator reason>   gateway.mjs:788
- *   max_tokens_no_output:<the whole string above>           gateway.mjs:1113
+ *   invalid_file:<rel(gradedArtifact)>:<validator reason>   runStageLadder() in gateway.mjs
+ *   max_tokens_no_output:<the whole string above>           runStageLadder() in gateway.mjs
  *
  * The file segment is variable and `max_tokens_no_output:` PREFIXES an otherwise ordinary token, so a
  * matcher keyed on the bare token misses the emitted string and reports a false unattached token. These
@@ -281,7 +281,7 @@ export const ARM1_EXEMPTIONS = [
   {
     token: "profile_unparseable",
     stages: ["common-law"],
-    reason: "The run's profile is config the driver loaded before the stage ran (verify.mjs:301). A corrupt profile is a config fault; no element of the common-law contract is about it.",
+    reason: "The run's profile is config the driver loaded before the stage ran (verify.mjs:301 COMMONLAW_UNAVAILABLE_RE). A corrupt profile is a config fault; no element of the common-law contract is about it.",
   },
   {
     token: "framework_manifest_unreadable",
@@ -303,7 +303,7 @@ export const ARM1_EXEMPTIONS = [
   {
     token: "plan_execution_unreadable",
     stages: ["register-digest", "narrative-refutation"],
-    reason: "The plan-execution receipt is written by the register tool lane, not by either stage (verify.mjs:1496, 1712). Unreadable is a tool/driver fault; both stages are only READERS of it.",
+    reason: "The plan-execution receipt is written by the register tool lane, not by either stage (verify.mjs:1496 rowLabel, 1712). Unreadable is a tool/driver fault; both stages are only READERS of it.",
   },
   {
     token: "grid_spec_unreadable",
@@ -318,7 +318,7 @@ export const ARM1_EXEMPTIONS = [
   {
     token: "coverage_form_empty",
     stages: ["register-digest"],
-    reason: "verify.mjs:1449, same artifact and same verdict in its own string: a form that parsed and carries no rows is \"(driver-written — this is a bug, not a model defect)\".",
+    reason: "verify.mjs:1449 connotationDispositionFail, same artifact and same verdict in its own string: a form that parsed and carries no rows is \"(driver-written — this is a bug, not a model defect)\".",
   },
   {
     token: "half_path_unrecognized",
@@ -331,7 +331,7 @@ export const ARM1_EXEMPTIONS = [
  * STAGE-UNREACHABLE VALIDATORS — not exemptions, a SCOPE statement.
  *
  * verify.mjs wires four validators no STAGES entry reaches: findings(1661), report(1719), audit(1728),
- * clientSummary(1736). They are NOT dead code — replay-archive.mjs:128 and mcp-server/lib/coverage.mjs:78
+ * clientSummary(1736). They are NOT dead code — replay-archive.mjs:128 replayRun and check() in mcp-server/lib/coverage.mjs
  * index validators[key] dynamically and the MCP server declares `audit` required — but no stage dispatches
  * them, so their tokens are unaccountable BY CONSTRUCTION with respect to a stage partition. The
  * client-summary STAGE was deleted 2026-08-01 (no line to cite: the stage is gone) and its validator outlived it.
@@ -343,7 +343,7 @@ export const STAGE_UNREACHABLE_VALIDATORS = [
   { validator: "findings", site: "driver/verify.mjs validators.findings", reason: "no STAGES entry names it; synthesis validates findings.json through validators.narrative's sibling checks instead" },
   { validator: "report", site: "driver/verify.mjs validators.report", reason: "report.md is ASSEMBLED by the driver (assembleReportMd); the validator survives as a post-assembly structural gate outside the stage table" },
   { validator: "audit", site: "driver/verify.mjs validators.audit", reason: "reached only through the MCP server's dynamic validators[key] lookup, which declares it required" },
-  { validator: "clientSummary", site: "driver/verify.mjs:1736", reason: "the client-summary STAGE was deleted 2026-08-01 (no line to cite: the stage is gone); the validator was not" },
+  { validator: "clientSummary", site: "driver/verify.mjs validators.clientSummary", reason: "the client-summary STAGE was deleted 2026-08-01 (no line to cite: the stage is gone); the validator was not" },
 ];
 
 /**
@@ -423,7 +423,7 @@ export const TRIPWIRE_OUT_OF_SCOPE = [
   {
     prefix: "register_plan_",
     site: "driver/register-plan.mjs",
-    reason: "parseRegisterPlan is called once from a validator (verify.mjs:2102) inside a try whose catch swallows it — `catch { /* no plan in reach — gate inactive */ }` at verify.mjs:2146. No throw of this family becomes a stage failure token.",
+    reason: "parseRegisterPlan is called once from a validator (validators.registerFindings in verify.mjs) inside a try whose catch swallows it — `catch { /* no plan in reach — gate inactive */ }` in the same validator. No throw of this family becomes a stage failure token.",
   },
 ];
 
@@ -526,12 +526,12 @@ export const INNER_CODES = Object.freeze([
   // `form_damaged` is minted in connotation-search.mjs AND coverage-form.mjs and becomes a different
   // token in each lane. The static census records the FIRST site it matched and no more, so its own
   // citation names one of the three mints — which is why `mints` is a list, and why a ruling copied from
-  // the census output would have been half a ruling. verify.mjs:1075 already states the rule this row
+  // the census output would have been half a ruling. verify.mjs:1075 parseCorrectionKinds already states the rule this row
   // records: `coverage_form_damaged`, never a bare `form_damaged`.
   { code: "form_damaged",
     mints: ["driver/connotation-search.mjs:2004", "driver/connotation-search.mjs:2080", "driver/coverage-form.mjs:876"],
     rollsUpTo: ["connotation_form_damaged", "coverage_form_damaged"],
-    why: "Minted in two lanes and namespaced per lane: verify.mjs:1019 for the meaning sweep, verify.mjs:1119 for the register digest. The namespacing is what keeps them apart — see verify.mjs:1075." },
+    why: "Minted in two lanes and namespaced per lane: verify.mjs:1019 parseCorrections for the meaning sweep, verify.mjs:1119 findReviewerCoherenceFlags for the register digest. The namespacing is what keeps them apart — see verify.mjs:1075 parseCorrectionKinds." },
 ]);
 
 /**

package/driver/degraded-parts.mjs

@@ -69,7 +69,14 @@ const readJsonl = (p) => {
   } catch { return []; }
 };
 
-/** The stage's own last attempt row, or null when the stage wrote none. */
+/**
+ * The stage's own last attempt row, or null when the stage wrote none.
+ *
+ * A PART IS DEGRADED WHEN ITS STAGE FAILED, and that is the row's `fail`, never its `ok`. The two said the
+ * same thing until the attempt row learned to record a session that reached an error result and was
+ * recovered (engine/session-record.mjs): such an attempt is not ok, and its stage still delivered. Whether
+ * that should reach a client's report is a ruling nobody has made, so this reads what it always meant.
+ */
 export function lastAttempt(runDir, stage) {
   const rows = readJsonl(driverDir(runDir, `${stage}.jsonl`))
     .filter((r) => Number.isFinite(Number(r?.attempt)) && typeof r.ok === "boolean");
@@ -93,7 +100,7 @@ function courtDecisions(runDir, log) {
   if (lastEvent(log, ["case-law-decision"])?.run !== true) return null;
   const last = lastAttempt(runDir, "case-law");
   const part = { part: "court-decisions", name: PART_NAMES.courtDecisions };
-  if (last?.ok === false) return { ...part, reason: reasonFor(last.fail), cause: `the case-law stage ended failed: ${last.fail ?? "no cause recorded"}` };
+  if (last?.fail) return { ...part, reason: reasonFor(last.fail), cause: `the case-law stage ended failed: ${last.fail}` };
   let text;
   try { text = readFileSync(join(runDir, "case-law-findings.md"), "utf8"); } catch { text = null; }
   if (text === null) return { ...part, reason: NOT_COMPLETED, cause: "case-law-findings.md is absent" };
@@ -119,7 +126,7 @@ const failedStep = (log, ok, failed) => {
 };
 const stageEnded = (runDir, stage) => {
   const last = lastAttempt(runDir, stage);
-  return last?.ok === false ? last : null;
+  return last?.fail ? last : null;
 };
 
 // The register's own steps, each of which the run survives without: the band's shape (the floors and the

package/driver/dispatch-record.mjs

@@ -46,6 +46,25 @@ export function dispatchFileName(stage, attempt, repair = 0) {
   return `${stage}.attempt${attempt}${repair ? `.repair${repair}` : ""}.${DISPATCH_SUFFIX}`;
 }
 
+export const STREAMS_DIR = "streams";
+
+/**
+ * `_driver/streams/<label>.attempt<N>.jsonl` (or `…repair<M>…`): the raw stream of the session that
+ * dispatch started, named as its dispatch record is. The engines write it (engine/session-record.mjs,
+ * `streamSink`); this is the one place the name is made. Absolute, through `driverDir`, so a label's
+ * colon is written the way the platform can hold it.
+ *
+ * IN ITS OWN FOLDER, NEVER BESIDE THE JOURNALS. Every `*.jsonl` directly under `_driver/` is read as a
+ * stage's attempt journal by name: the token rollup sums its usage rows, the degraded-parts check reads
+ * its label off the file name, the integrity check leaves it out as append-only. A raw stream there
+ * would be counted as a stage and its usage summed twice. One folder down, no reader of `_driver/`
+ * lists it, and the integrity snapshot reads files only.
+ */
+export function streamFilePath(runDir, stage, attempt, repair = 0) {
+  if (!runDir) return null;
+  return join(driverDir(runDir), STREAMS_DIR, driverFileName(`${stage}.attempt${attempt}${repair ? `.repair${repair}` : ""}.jsonl`));
+}
+
 const shaOf = (buf) => createHash("sha256").update(buf).digest("hex").slice(0, 12);
 
 // ── — WHAT THE STAGE WAS GRANTED, BESIDE THE SHA THAT PROVES WHAT IT WAS ASKED ────────────────

package/driver/doubt-closure-tool.mjs

@@ -119,8 +119,8 @@ export function captureCall(runDir, seq, received, { now = () => new Date().toIS
 //
 // THAT PREMISE IS WHY THIS IS SAFE, SO CHECK IT BEFORE MOVING THE SPEC WRITE. Five of the six
 // doubt-minting sites build an id from an ordinal over a FILTERED list
-// (`presence-reconciliation.mjs:182` mints `doubt:presence:<sheet>:<n>` after three `continue` filters,
-// with `status: "open"` hardcoded beside it); `doubt-ledger.mjs:232` is the exception and the template,
+// (`presence-reconciliation.mjs:182 mintPresenceDoubts` mints `doubt:presence:<sheet>:<n>` after three `continue` filters,
+// with `status: "open"` hardcoded beside it); `doubt-ledger.mjs:232 mintContradictionDoubts` is the exception and the template,
 // putting the candidate name in the id and using the ordinal only as a tiebreaker. If the spec is ever
 // minted per attempt instead of per stage, those ordinals can shift between attempts and this serve
 // starts handing back a verdict about a different subject. Nothing else in this file would notice.

package/driver/driver.config.mjs

@@ -1337,6 +1337,10 @@ export const PROVIDERS = {
         return { ok: true,
           total: Number.isFinite(p.total_hits) ? p.total_hits : null,
           ...(p.total_approximate === true ? { approximate: true, floor: Number.isFinite(p.total_floor) ? p.total_floor : null } : {}),
+          // The register's own notes on this answer, carried whole as the clearance sweep carries them —
+          // `expanded_fallback` among them, which says the total counts records rather than marks. The
+          // knockout listing dropped them, so a knockout run could not show what a clearance run shows.
+          ...(Array.isArray(p.warnings) && p.warnings.length ? { warnings: p.warnings } : {}),
           records: (Array.isArray(p.results) ? p.results : []).map((row) => {
           const rec = row?.raw && typeof row.raw === "object" ? core.normalizeRecord(row.raw, row.office || null) : null;
           return {
@@ -1355,6 +1359,9 @@ export const PROVIDERS = {
             filing_route: rec?.filingRoute ?? null,
             // No page per record at Signa (hasPublicRecordUrl: false above), and none is made up here.
             record_url: null,
+            // The office's own page as the register gives it, for publish to fall back on where it cannot
+            // address the office's page from the numbers above (office-record-links.mjs).
+            office_url: rec?.officeUrl ?? null,
           };
         }) };
       } catch (e) { return { ok: false, records: null, reason: `listRecords threw: ${e.message}` }; }
@@ -2079,12 +2086,31 @@ export const ENGINE_BINARIES = {
     // and a pinned id was refused outright ("version 2.1.280 or newer is required"), measured 2026-09-22.
     // A floor that only asks for a program that starts is a floor that passes a machine this engine
     // cannot run the current generation on.
-    package: "@anthropic-ai/claude-code", floor: "2.1.284",
+    //
+    // THE HAIKU TIER CROSSED LATER, when Claude Haiku 5.5 joined the generation. Measured 2026-10-09 by a
+    // one-word `-p` turn per version on the test box's own sign-in, reading the model the turn reports in
+    // `modelUsage`:
+    //
+    //     version   --model haiku
+    //     2.1.285    claude-haiku-4-5-20251001
+    //     2.1.287    claude-haiku-4-5-20251001
+    //     2.1.288    claude-haiku-4-5-20251001
+    //     2.1.289    claude-haiku-4-5-20251001
+    //     2.1.290    claude-haiku-4-5-20251001
+    //     2.1.292    claude-haiku-4-5-20251001
+    //     2.1.293    claude-haiku-5-5
+    //     2.1.294    claude-haiku-5-5
+    //     2.1.295    claude-haiku-5-5
+    //
+    // 2.1.295 still serves claude-opus-5-5 and claude-sonnet-5-5. The floor moves to 2.1.293 for the reason
+    // it moved to 2.1.284: a stage that asks for haiku is asking for the current haiku.
+    package: "@anthropic-ai/claude-code", floor: "2.1.293",
     // WHAT THE INSTALL TAKES ON DISK, in MB, which setup states before it asks to install. MEASURED, not
     // declared by the vendor: the engines folder after a fresh install of this package into an empty
-    // folder, on npm 10.9.8 and on 11.19.1, 2026-09-14. A later release can be larger or smaller, so setup
-    // says "about". Re-measure when the floor moves.
-    installMB: 233,
+    // folder. Re-measured when the floor moved to 2.1.293: 242 MB for a fresh install of 2.1.293 itself,
+    // on npm 10.9.9, 2026-10-09. A later release can be larger or smaller, so setup says "about".
+    // Re-measure when the floor moves.
+    installMB: 242,
     // The licence setup states wherever it tells a reader what they are about to install or use, as the
     // vendor's package declares it: "SEE LICENSE IN README.md", Anthropic's own terms.
     licence: "proprietary third-party software",
@@ -2110,8 +2136,15 @@ export const ENGINE_BINARIES = {
     vendor: "OpenAI",
     product: "Codex",
     env: "CLEAROTRON_CODEX_PATH", fallback: "codex",
-    package: "@openai/codex", floor: "0.154.0",
-    installMB: 324,   // measured the same way and on the same day as Claude's, above
+    // THE FLOOR IS THE OLDEST RELEASE THAT ACCEPTS THE JUDGMENT TIER'S MODEL on a ChatGPT sign-in, which
+    // is how a subscription bills. Measured 2026-10-09 with a one-word `codex exec` turn per version on the
+    // test box: `gpt-6.1-sol` is refused with a 400 on 0.156.1, 0.157.0 and 0.158.0 ("not supported when
+    // using Codex with a ChatGPT account") and accepted on 0.159.0, 0.160.0, 0.161.0 and 0.162.0;
+    // `gpt-6-luna` is accepted from 0.156.1. Below the floor every clearance stops at its first
+    // judgment-tier stage (the tiers are in engine/openai-agent.mjs). The old floor, 0.154.0, was the
+    // permissions feature's (engine/mcp/codex-config.mjs).
+    package: "@openai/codex", floor: "0.159.0",
+    installMB: 424,   // re-measured the same way as Claude's, above: a fresh install of 0.159.0 itself, 2026-10-09
     licence: "third-party software under the Apache-2.0 licence",   // the package's own "license" field
     label: "OpenAI — each stage runs as a headless `codex exec` turn",
     module: "engine/openai-agent.mjs", adapter: "openaiAgentEngine",

package/driver/engagement-receipt.mjs

@@ -37,7 +37,7 @@ export function isFinding(heading, block) {
 
 // Distinctive word anchors (length ≥4, non-stopword) from the owner / element / goods / sector /
 // jurisdiction / mark vocabulary; multi-word anchors contribute their significant words (so a finding
-// mentioning "Plesner" anchors against owner "Plesner Advokatpartnerselskab").
+// mentioning "Varnholt" anchors against owner "Varnholt Advokatpartnerselskab").
 function anchorTerms(anchors = {}) {
   const raw = [
     ...(anchors.owners ?? []), ...(anchors.dominantElements ?? []), ...(anchors.goodsServices ?? []),

package/driver/engine/CONTRACT.md

@@ -36,7 +36,9 @@ ladder consumes it without knowing which engine produced it ([gateway.mjs](../ga
   laneWaitMs: number,
   json:       object | null,         // synthesized envelope in the classifier's shape; every downstream
                                      // classifier (payloadText, status, embedded-fallback, timeout,
-                                     // lane-wedge) reads this and works unchanged across engines
+                                     // lane-wedge) reads this and works unchanged across engines.
+                                     // It also carries how the session ended: terminalReason,
+                                     // apiErrorStatus and errorText (see `session` below)
   usage:      Usage | null,          // canonical shape below; null = no tokens accounted (e.g. stall)
   sessionRef: string | null,         // opaque resume handle (claude session_id | codex thread_id)
   modelWire:  string | null,         // MODEL GAUGE — the served model id this turn observed (§3);
@@ -57,9 +59,47 @@ ladder consumes it without knowing which engine produced it ([gateway.mjs](../ga
                                      // opened; [] = recorded "read nothing"; key absent = engine cannot
                                      // observe reads (openai-agent) → gateway journals `reads: null`
   readsTruncated: boolean | absent,  // true = the path cap dropped at least one further distinct file
+  toolCallsByName: object | null,    // the turn's tool calls by tool name; an MCP call is
+                                     // `mcp__<server>__<tool>` on both engines; null = no session ran
+  session:    Session | null,        // what the session went through (below); null = no session ran
+  stream:     { file, present, bytes, reason? } | null,
+                                     // the raw stream, written to the file the caller named
+                                     // (the gateway names _driver/streams/<label>.attempt<N>.jsonl)
 }
 ```
 
+### `session` — what the session went through
+
+Both engines used to keep only the LAST result of a session, so a session the vendor's classifier cut
+off mid-answer, or refused and a restart recovered, ended in a successful result and was recorded as
+clean. `session` keeps every event of that kind, as the program wrote it, with milliseconds since the
+spawn ([engine/session-record.mjs](session-record.mjs)):
+
+```
+Session { interrupted, starts, results: [{atMs, index, subtype, isError, stopReason, terminalReason, origin}],
+          classifierCuts: [{atMs, synthetic}], refusals: [{atMs, category, model}], refusalStops }
+```
+
+It carries kinds, codes and times, never the program's words. The retry ladder still reads the last
+result alone; the gateway journals the attempt as `ok: false` when any result carried `is_error`, while
+`fail` — what every reader of "did the stage fail" reads — is unchanged. Codex states no cut or refusal
+on its stream, so on that engine `results` lists every `turn.completed`, `turn.failed` and `error`.
+
+How the session ended rides the envelope, and the gateway writes it on every attempt and repair row,
+null where the engine said nothing:
+
+```
+terminalReason   the kind of ending as the program states it (claude `terminal_reason`); null on codex
+apiErrorStatus   the vendor's status when it gave one (claude `api_error_status`); null on codex
+errorText        the program's own words for the error, only when the session ended in one, cut to
+                 300 characters: claude's result text when that result has `is_error`; codex's
+                 `turn.failed` message, or its stream error when the turn never completed
+```
+
+These are the one place the record holds the program's words: an expired sign-in otherwise reads as
+`stop_sequence` and nothing else. `stopReason` stays verbatim beside them, and none of the three moves a
+verdict.
+
 `runStage()` folds that into what the pipeline consumes — `{ok, json, attempts, text, sessionKey, …}` —
 and journals usage/wall/status on the way past.
 

package/driver/engine/anthropic-agent.mjs

@@ -26,6 +26,7 @@ import { authorityTrees } from "../authority-trees.mjs";
 import { recordEngineChild, clearEngineChild } from "./child-record.mjs";   //
 import { engineEnv } from "./engine-env.mjs";   // — the program's environment, by list (see spawnEnv)
 import { engineSpawn, spawnsDetached, killWindowsTreeNow } from "./engine-spawn.mjs";   // one answer to how a turn starts and ends, on every platform
+import { newSessionRecord, noteClaudeEvent, sessionSummary, countTool, streamSink, claudeEnding } from "./session-record.mjs";   // what the session went through, beside how it ended
 
 // Read per-call (not module-level) so tests can drive a short stall timeout / a mock binary.
 // ONE place knows how to find the program (driver.config.mjs resolveEngineProgram): the explicit setting,
@@ -514,6 +515,9 @@ export function synthesizeEnvelope({ resultEvent, usage, killed }) {
     status: ok ? "ok" : (killed ? "timeout" : "error"),
     result: { meta: { agentMeta: { usage } }, payloads: [{ text }] },
     summary: r?.subtype, runId: r?.session_id, stopReason: r?.stop_reason,
+    // …and beside the stop reason, what ended the session and, on an error, the program's own words for it
+    // (session-record.mjs, claudeEnding). Recorded only: `ok` above reads exactly what it read before.
+    ...claudeEnding(r),
   };
 }
 
@@ -524,7 +528,7 @@ export const anthropicAgentEngine = {
   // doctrine tree, the profile store and `<runDir>/_driver/` at the moment of the write. That is a real
   // boundary and this engine has it.
   writeBoundary: "enforced",
-  async runTurn({ message, model, thinking, timeoutSec, resumeRef, mcpConfig, allowedTools, cwd, skillsDir, skillsGrantRoots, profilesDir, resolveSkill, runDir, seatWrites = null, grantDispatch = null, stallSec, progressFiles } = {}) {
+  async runTurn({ message, model, thinking, timeoutSec, resumeRef, mcpConfig, allowedTools, cwd, skillsDir, skillsGrantRoots, profilesDir, resolveSkill, runDir, seatWrites = null, grantDispatch = null, stallSec, progressFiles, streamFile = null } = {}) {
     if (!message) throw new Error("anthropic-agent.runTurn: message is required");
     const { args, input, grantNote } = buildClaudeArgs({ message, model, thinking, resumeRef, mcpConfig, allowedTools, cwd, skillsDir, skillsGrantRoots, profilesDir, resolveSkill, runDir, seatWrites, grantDispatch });
     // the cross-check speaks. Driver stderr is what an operator reads, and it is where the other
@@ -690,6 +694,24 @@ export const anthropicAgentEngine = {
       // ("a completed tool result = the agent loop advanced", below). The gap between them is the turn
       // waiting on tools rather than generating.
       let toolCalls = 0;
+      // …AND THE SAME CALLS BY TOOL NAME, so a tool server's own log can be set against what the model
+      // asked for. A name is the program's identifier for a tool (`Read`, `mcp__band__band_lookup`), never
+      // an input, so it carries no client text. The values sum to `toolCalls` by construction: one fold
+      // per tool_use block, at the one site that counts them.
+      const toolCallsByName = Object.create(null);
+      // …AND WHICH OF THEM A TOOL SERVER ANSWERED WITH AN ERROR. A refused call the model then re-made used to
+      // leave the stage row reading ok on one attempt, as though nothing had happened. Each ask's id names its
+      // tool, and its result says whether it came back as an error; nothing else is kept.
+      const toolNameById = new Map();
+      const toolErrorIds = new Set();
+      // WHAT THE SESSION WENT THROUGH, beside how it ended: every result event, every classifier cut,
+      // every refusal and every restart, each with when it arrived. See session-record.mjs; the retry
+      // policy below still reads the LAST result alone, so this records and decides nothing.
+      const session = newSessionRecord();
+      // The raw stream, one file per session beside its dispatch (the caller names it). Opened before the
+      // first byte can arrive; closed in settle(). A sink that could not open is a null writer whose
+      // close() says why.
+      const sink = streamSink(streamFile);
       // HOW MANY OF THOSE ASKED FOR A COMMAND TOOL. The command tools are removed from every stage
       // (COMMAND_TOOLS), so the number a test round expects here is zero, and a count is what proves it: a
       // flag in the argv shows what was asked of the program, this shows what the model did. Still a count
@@ -814,6 +836,7 @@ export const anthropicAgentEngine = {
         let ev;
         try { ev = JSON.parse(line); } catch { return; /* partial/non-json line */ }
         sawAnyEvent = true;
+        noteClaudeEvent(session, ev, Date.now() - t0);
         if (ev.type === "result") resultEvent = ev;
         else if (ev.type === "rate_limit_event") rateLimitEvent = ev;
         else if (ev.type === "system" && ev.subtype === "init") {
@@ -839,7 +862,8 @@ export const anthropicAgentEngine = {
           // classification and no recovery park, or the turn never settles with its watchdog already gone.
           // Same belt-and-braces as the thinking gauge's `?.some?.()` on the line above.
           for (const b of Array.isArray(ev.message?.content) ? ev.message.content : []) {
-            if (b?.type === "tool_use") toolCalls++;   // #1111 — every tool, not only Read; a COUNT, never a name
+            if (b?.type === "tool_use") { toolCalls++; countTool(toolCallsByName, b?.name); }   // #1111 — every tool, not only Read; the count and its split by name
+            if (b?.type === "tool_use" && b?.id != null) toolNameById.set(String(b.id), String(b?.name ?? "?"));
             if (b?.type === "tool_use" && COMMAND_TOOLS.includes(b?.name)) commandToolCalls++;
             if (b?.type === "tool_use" && FILE_WRITE_TOOLS.includes(b?.name) && b?.id != null) writeAsks.add(String(b.id));
             if (b?.type === "tool_use" && b?.name === "Read" && typeof b?.input?.file_path === "string") {
@@ -873,8 +897,10 @@ export const anthropicAgentEngine = {
           progress();
         }
         else if (ev.type === "user") {
-          for (const b of Array.isArray(ev.message?.content) ? ev.message.content : [])
+          for (const b of Array.isArray(ev.message?.content) ? ev.message.content : []) {
             if (b?.type === "tool_result" && b?.is_error === true && writeAsks.has(String(b?.tool_use_id))) writesFailed++;
+            if (b?.type === "tool_result" && b?.is_error === true && b?.tool_use_id != null) toolErrorIds.add(String(b.tool_use_id));
+          }
           // the result of the ask above. Only counted when an ask is outstanding, so a `user`
           // event with no preceding tool_use adds nothing rather than charging the turn for a gap it
           // never spent waiting.
@@ -1052,6 +1078,7 @@ export const anthropicAgentEngine = {
         chunkGapMs = prevChunkAt === null ? 0 : Date.now() - prevChunkAt;
         prevChunkAt = Date.now();
         lastMove = Date.now();   // ANY streamed byte = liveness → resets the stall clock
+        sink.write(d);           // the raw stream, byte for byte, before anything parses it
         buf += d.toString();
         let nl;
         while ((nl = buf.indexOf("\n")) >= 0) { parseLine(buf.slice(0, nl)); buf = buf.slice(nl + 1); }
@@ -1074,7 +1101,7 @@ export const anthropicAgentEngine = {
         if (stderr.length > maxBuffer) { stderr = stderr.slice(0, maxBuffer); overflowKill(); }
       });
       // error + close can BOTH fire for a single failure (Node) → settle EXACTLY once (no double clearInterval/resolve).
-      child.on("error", (e) => { if (settled) return; settled = true; clearInterval(watchdog); resolve(errResult(t0, e, resumeRef)); });
+      child.on("error", (e) => { if (settled) return; settled = true; clearInterval(watchdog); sink.close(); resolve(errResult(t0, e, resumeRef)); });
       child.on("close", (code) => settle(code));
       function settle(code) {
         // the turn is over; the record must not outlive it, and is cleared only if
@@ -1087,6 +1114,7 @@ export const anthropicAgentEngine = {
         try { child.stdout.destroy(); } catch { /* stream gone */ }
         try { child.stderr.destroy(); } catch { /* stream gone */ }
         if (!overflow) { parseLine(buf); }   // B1: flush the final, un-terminated line (the result event) — but NEVER the truncated overflow tail
+        const stream = sink.close();   // after the flush: every byte the program wrote is in it, or the record says why not
         buf = "";
         // ONE SAMPLE OF THE CLOCK, and both quantities below are derived from it. Two `Date.now()` calls
         // a few milliseconds apart are enough to break the identity on the very turn it matters for: on a
@@ -1176,11 +1204,18 @@ export const anthropicAgentEngine = {
           // from this list is unreliable and the consumer must downgrade it to "not observed").
           reads: [...reads], readsTruncated,
           toolCalls, toolWaitMs: settledToolWaitMs,   // #1111 — two integers, no content
+          // The same calls by tool name (values sum to toolCalls), and what the session went through: every
+          // result, cut, refusal and restart (session-record.mjs). `stream` is the raw stream's file and size,
+          // or why it was not kept. Recording only — `failed` above still reads the last result alone.
+          toolCallsByName: { ...toolCallsByName }, session: sessionSummary(session), stream,
           // The two counts a test round reads per stage: calls to a command tool, and calls the program
           // refused. The refusals are the result event's own `permission_denials`, counted; null when the
           // turn settled with no result event, so "not reported" never reads as "none refused".
           commandToolCalls, writesFailed,
           toolCallsRefused: Array.isArray(resultEvent?.permission_denials) ? resultEvent.permission_denials.length : null,
+          // The tool-server calls that came back as an error, by tool name: the program sent them and the
+          // server refused or failed them. A call the program itself refused is counted above and not here.
+          toolCallsErroredByName: toolServerErrors(toolErrorIds, toolNameById, resultEvent?.permission_denials),
           // ms from spawn to the child's FIRST byte, or null when it never spoke. RECORDING
           // ONLY: nothing branches on it. A recording field is protected by a test or by nothing, so
           // engine.anthropic.test.mjs pins it — deleting it must red something.
@@ -1253,9 +1288,26 @@ function errResult(t0, e, resumeRef) {
     // modelWire: null for the opposite reason — no turn ran, so the wire said nothing about a model, and
     // the record must say UNKNOWN rather than inherit the alias that was asked for.
     json: null, usage: null, reads: [], readsTruncated: false, modelWire: null, providerWire: null, sessionRef: resumeRef ?? null,
+    // No session ran, so there is nothing to have been interrupted and no stream: null, never an empty record.
+    toolCallsByName: null, toolCallsErroredByName: null, session: null, stream: null,
   };
 }
 
+/**
+ * The tool-server calls of one turn that came back as an error, by tool name: every `mcp__` ask whose
+ * result carried `is_error`, less the asks the program refused itself (`permission_denials`, which
+ * `toolCallsRefused` counts). An OBJECT is a measurement (`{}`: none). PURE.
+ */
+export function toolServerErrors(errorIds, nameById, denials) {
+  const denied = new Set((Array.isArray(denials) ? denials : []).map((d) => String(d?.tool_use_id ?? "")).filter(Boolean));
+  const byName = Object.create(null);
+  for (const id of errorIds ?? []) {
+    const name = nameById?.get(id);
+    if (typeof name === "string" && name.startsWith("mcp__") && !denied.has(id)) countTool(byName, name);
+  }
+  return { ...byName };
+}
+
 /**
  * The program's own word for which provider served a turn, from the result event's per-model usage:
  * `modelUsage[<model>].provider`, "firstParty" on Anthropic's own API and "foundry" on Azure Foundry

package/driver/engine/mcp/codex-config.mjs

@@ -218,7 +218,7 @@ export function commandEnvToml(withheld = []) {
 // ── the stage's permission profile: what its shell commands may read and write ──────────────────────
 // codex's `workspace-write` sandbox confines where a command WRITES and lets it read the whole disk, the
 // install's settings files and the program's own sign-in included. A permission profile confines reading
-// too (the vendor's Permissions guide, a beta feature since 0.138.0; the floor is 0.154.0): a stage's
+// too (the vendor's Permissions guide, a beta feature since 0.138.0; the floor was 0.154.0 when this was written and is 0.159.0 now, for the judgment tier's model — driver.config.mjs): a stage's
 // commands read the platform's own paths, the instruction trees and the temp folders, and write the run
 // folder, their working folder and the temp folders. Nothing else is readable, so a page a stage fetched
 // cannot get a command to print the account's files. The temp folders stay writable because

package/driver/engine/mcp/coverage-server.mjs

@@ -19,7 +19,7 @@
 // wired per run by the driver; there is no parameter for it and this tool never guesses one
 // (recording-server.mjs's record_doubt_closure records why the parameter must not exist). The form name comes off the run's own
 // era stamp, the row ids are the driver's, and every other identifier is computed. Read at CALL TIME,
-// never captured at module load (stdio-server.mjs:29-33 states why for exactly this variable).
+// never captured at module load (stdio-server.mjs:29-33 toolLogPath states why for exactly this variable).
 import { serve } from "./stdio-server.mjs";
 import { recordCoverage } from "../../coverage-tool.mjs";
 import { MAX_ROWS_PER_CALL } from "../../coverage-call.mjs";

package/driver/engine/mcp/gather-config.mjs

@@ -107,7 +107,7 @@ export const REGISTER_SERVERS = {
   //     public page, and this provider publishes neither. Read 2026-08-22 across providers/signa/src: no
   //     vienna or figurative field anywhere in the core, the normaliser carries `imageAvailable`
   //     (`rec.has_media`) and nothing else about the mark's figure, `hasPublicRecordUrl: false` and
-  //     `resolved_link: null` with "Signa exposes no per-record public URL". Serving it would return a
+  //     `resolved_link: null` (no page per record of its own). Serving it would return a
   //     bare boolean under a name that promises comparable figurative data. NOT A PROBE: this is a read of
   //     the code and the vendor doc in this repo, and whether the live API has an image endpoint nobody
   //     wired is UNTESTED from here — euipo's `markImage` looked equally absent until `GET

package/driver/engine/mcp/recording-server.mjs

@@ -5,7 +5,7 @@
 // ── WHAT THIS CATEGORY IS FOR, AND WHY IT IS NOT A RETRIEVAL GRANT ──────────────────────────────────
 //
 // The two-box model conflates "may reach the outside world" with "may hand back structure"
-// (gather-config.mjs:246-268). A stage converted to a typed return needs the second and not the first.
+// (gather-config.mjs:246-268 RECORDING). A stage converted to a typed return needs the second and not the first.
 // This server carries ONLY the second: it writes the calling stage's own artifact into the calling
 // stage's own run directory, and it dials nothing.
 //
@@ -55,7 +55,7 @@ import { PROVIDERS, REGISTER_PROVIDER } from "../../driver.config.mjs";
 // already written against them; this conversion is the consumption their headers said was still owed.
 import { recordClosures } from "../../doubt-closure-tool.mjs";
 import { MAX_CLOSURES_PER_CALL, CLOSURE_KINDS } from "../../doubt-closure-call.mjs";
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs"; import { FROZEN_METHOD_FILE } from "../../framework-method.mjs";
 import { join } from "node:path";
 import { driverDir } from "../../../shared/driver-dir.mjs";   //
 import { VARIANT_CATEGORIES } from "../../variant-manifest-model.mjs";
@@ -398,7 +398,7 @@ serve({
               item: {
                 type: "string",
                 description:
-                  "For a FIRING variant directive this must be a mark-shaped search term (TAKIS, CORAL " +
+                  "For a FIRING variant directive this must be a mark-shaped search term (WAVA, CORAL " +
                   "MAGIC) or carry a remedy. A label — a parenthetical, an enumeration, more than about " +
                   "four words — dispatches as a nil search that reads CLEAN, and is refused here.",
               },
@@ -1134,6 +1134,9 @@ serve({
     handler: record_synthesis,
   }, {
     name: "record_knockout_assess",
+    // The framework's `inputs` fields are offered only on a run whose framework states a method: a session
+    // offered a field it may not use can fill it, and the check that refuses it runs after the whole step.
+    schemaNow: (schema) => knockoutAssessSchemaFor(schema, process.env.CLEAROTRON_BAND_RUN_DIR),
     description:
       "Hand back THIS CHUNK's rated assessment as VALUES. The driver serializes knockout-assess-<n>.json, " +
       "so you never format JSON and never write the file. WHICH CHUNK IS NOT YOURS TO SAY — the driver " +
@@ -1392,7 +1395,7 @@ serve({
         },
         batch: {
           type: "object",
-          required: ["productContext", "inUseAs", "places"],
+          required: ["productContext", "inUseAs"],   // places are per name (ruling 570): the batch list is optional, as in the acceptor and the manual
           properties: {
             productContext: { type: "string", description: "One sentence: what the batch is for. Every mark's contextFraming is read against it." },
             inUseAs: { type: "string", description: "The kinds of use off the register that could conflict in this client's field, as one phrase completing \"Is this name already in use as …?\". The places the batch is searched on include the sites where these uses are listed." },
@@ -1439,3 +1442,27 @@ serve({
     handler: record_knockout_frame,
   }],
 });
+
+/**
+ * The knockout save tool's schema for the run this server serves. The framework's `inputs` fields are
+ * offered only where the run's framework states a method, which is when its frozen copy
+ * (`_driver/framework-method.json`) exists: a run with no method has none, since the mint removes it. A
+ * session offered a field it may not use can fill it, and the check that refuses it runs only after the
+ * whole step. With no run to read, the schema is the one declared. Read when the tools are listed.
+ */
+export function knockoutAssessSchemaFor(schema, runDir) {
+  if (!runDir || existsSync(driverDir(String(runDir), FROZEN_METHOD_FILE))) return schema;
+  const strip = (s) => {
+    if (Array.isArray(s)) return s.map(strip);
+    if (!s || typeof s !== "object") return s;
+    const out = {};
+    for (const [k, v] of Object.entries(s)) {
+      if (k === "properties" && v && typeof v === "object" && !Array.isArray(v)) {
+        out.properties = Object.fromEntries(Object.entries(v).filter(([name]) => name !== "inputs").map(([name, sub]) => [name, strip(sub)]));
+      } else if (k === "required" && Array.isArray(v)) out.required = v.filter((name) => name !== "inputs");
+      else out[k] = strip(v);
+    }
+    return out;
+  };
+  return strip(schema);
+}