clearotron 0.4.1 → 0.5.0-beta.1

package/driver/engine/mcp/supplemental.mjs

@@ -32,10 +32,18 @@
 import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { driverDir } from "../../../shared/driver-dir.mjs";   //
-import { PLAN_PREDICATES, PLAN_MAX_OR_WIDTH, PLAN_MAX_NAME_LENGTH, fingerprint, ownerIntersectionGap, goodsTextGap, resolveRegions, houseElementOf, withoutHouseElementTerms, containsFormSubstitution } from "../../register-plan.mjs";
+import { PLAN_PREDICATES, PLAN_MAX_OR_WIDTH, PLAN_MAX_NAME_LENGTH, planExactOrWidth, planPhoneticOrWidth, fingerprint, ownerIntersectionGap, goodsTextGap, resolveRegions, houseElementOf, withoutHouseElementTerms, containsFormSubstitution } from "../../register-plan.mjs";
 import { entryTermIssues } from "../../../providers/_shared/term-shape.mjs";
+import { OUTSTANDING_REASON } from "../../../providers/_shared/follow-up-searches.mjs";
+import { heldAnswers, questionKey } from "./held-answers.mjs";
+import { readWithheldFamilies } from "../../withheld-families.mjs";
 import { isNonLatinTerm, romanizationRefusal, romanizationSpellings, nativeScriptIndexGap } from "../../../providers/_shared/script-form.mjs";
 
+// THE ONE SENTENCE THE MODEL READS WHEN THE RUN'S SAFETY NET HOLDS A FOLLOW-UP BACK (follow-up-searches.mjs). It names
+// no limit and no cost: the model is never told of the net. It rides the reply whenever a question was not sent, now
+// or by an earlier decision held for the run.
+export const OUTSTANDING_NOTE = "Not asked in this run. Keep it as an open question with your reason, and continue with what you have read.";
+
 const slug = (s) => String(s ?? "").toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "q";
 
 const PREVIEW_FIELDS = ["record_id", "mark_text", "classes", "status", "owner_name", "owner_country", "screen_verdict"];
@@ -57,17 +65,20 @@ const compactProposal = (p) => ({
 const inPriority = (p, prio) =>
   (Array.isArray(p?.nice_classes) ? p.nice_classes : []).some((c) => prio.has(String(c).trim()));
 
-// A SOUND-ALIKE BATCH GOES AS LISTS where the register takes one (`phoneticOrWidth`, ruled 2026-10-09): up to
-// that many spellings per question, within its word budget, each long enough for the ranked search. A
-// spelling below that floor is its own question, as every name of a batch was before. Each list is one
-// question with one receipt row, so a list that crowds or fails takes no other list down with it. PURE.
+// A BATCH OF SPELLINGS GOES AS THE PLANNER'S LISTS where the register takes one: exact spellings up to
+// `exactOrWidth`, sound-alike ones up to `phoneticOrWidth` within the register's word budget (ruled 2026-10-09
+// for sound-alikes; the exact width is the one the plan's own spelling band already uses), each spelling long
+// enough for the ranked search. A spelling below that floor is its own question, and so is every name of a batch
+// with an owner or on any other predicate, as before. Each list is one question with one receipt row, so a list
+// that crowds or fails takes no other list down with it. PURE.
 function splitBatch(p, names, capabilities) {
   const { terms: _batch, ...rest } = p;
   const single = (t) => ({ ...rest, term: t });
-  const width = Math.floor(Number(capabilities?.phoneticOrWidth));
-  if (String(p?.predicate ?? "") !== "phonetic" || !(width >= 2)) return names.map(single);
+  const predicate = String(p?.predicate ?? "");
+  const width = predicate === "exact" ? planExactOrWidth(capabilities) : predicate === "phonetic" ? planPhoneticOrWidth(capabilities) : 1;
+  if (!(width >= 2) || (typeof p?.owner === "string" && p.owner.trim())) return names.map(single);
   const floor = Number(capabilities?.rankedMinLength) || 0;
-  const budget = Number(capabilities?.listWordBudget) || Infinity;
+  const budget = predicate === "phonetic" ? (Number(capabilities?.listWordBudget) || Infinity) : Infinity;
   const words = (t) => t.split(/\s+/).filter(Boolean).length;
   const folded = (t) => [...t.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/\s+/g, "")].length;
   const out = [];
@@ -427,9 +438,29 @@ export async function proposeSupplemental(params, tctx, deps) {
   if (!offered.length)
     return { type: "text", text: JSON.stringify({ minted: [], reused: [], rejected: [], excluded_house_element: excludedHouse, executed: false }, null, 2) };
   const existingQids = new Set(supp.entries.map((e) => e.qid));
-  const { minted, reused, rejected, enriched, narrowed } = mintSupplementalEntries(axis, offered,
+  let { minted, reused, rejected, enriched, narrowed } = mintSupplementalEntries(axis, offered,
     { existingQids, capabilities: deps.capabilities ?? null, priorityClasses: planClasses });
 
+  // ── ONE ANSWER PER QUESTION PER RUN (held-answers.mjs) ───────────────────────────────────────────
+  // A question another worker or pass has already answered gets that answer, and one the run has decided not to ask
+  // gets that decision: it is not minted, not run, and costs no call. A failed answer is no answer, so it is asked again.
+  const held = [];
+  try {
+    const runDir = dirname(dirname(outPath));
+    const index = heldAnswers(runDir, { planRegions, withheld: readWithheldFamilies(runDir) });
+    if (index.size) {
+      const fresh = [];
+      for (const e of minted) {
+        const h = index.get(questionKey(e, planRegions));
+        if (!h || h.qid === e.qid) { fresh.push(e); continue; }
+        held.push({ question: compactProposal(e), decision: h.decision, ...(h.qid ? { answered_by: h.qid, axis: h.axis } : {}),
+          ...(h.block ? { state: h.block.state ?? null, total_hits: h.block.total_hits ?? null,
+            count: h.block.count ?? (Array.isArray(h.block.records) ? h.block.records.length : null), records_preview: preview(h.block.records) } : {}) });
+      }
+      minted = fresh;
+    }
+  } catch { /* the held index is an economy: without it every question is asked as before */ }
+
   // Field-level romanisation enrichment of a REUSED qid (2026-07-30 review round): the natural retry —
   // a bare non-Latin proposal deferred at the wire, the model re-proposes it WITH the romanisation —
   // reuses the same deterministic qid, and without this the stored bare entry re-executed verbatim and
@@ -486,7 +517,15 @@ export async function proposeSupplemental(params, tctx, deps) {
     renameSync(`${suppPath}.tmp`, suppPath);
   }
 
-  const qids = [...minted.map((e) => e.qid), ...reused];
+  // A question this worker re-proposes that already holds an answer is not run again: the answer stands. One with no
+  // answer, a failed one, or one this call enriched or gave its markets runs as before.
+  let reusedHeld = [];
+  try {
+    const own = new Map();
+    for (const b of JSON.parse(readFileSync(outPath, "utf8"))) if (b?.qid) own.set(String(b.qid), b);
+    reusedHeld = reused.filter((q) => { const b = own.get(String(q)); return b && b.error !== true && !enrichedQids.includes(q) && !staleOnDisk; });
+  } catch { reusedHeld = []; }
+  const qids = [...minted.map((e) => e.qid), ...reused.filter((q) => !reusedHeld.includes(q))];
   let summary = null;
   if (qids.length) {
     const r = await executePlan({ plan_path: suppPath, axis, output_path: outPath, qids }, tctx);
@@ -497,13 +536,36 @@ export async function proposeSupplemental(params, tctx, deps) {
     try { summary = JSON.parse(text); } catch { summary = { raw: text.slice(0, 300) }; }
   }
 
+  // A FOLLOW-UP THE RUN'S SAFETY NET DID NOT SEND never ran and has no answer (follow-up-searches.mjs). One minted by this
+  // call leaves the plan the fold reads, so it is never taken for a planned question that went missing, and is
+  // kept as a question not asked: a rejected[] row, which the ask ledger keeps open. One that ran before keeps its
+  // place and its answer.
+  const outstanding = Array.isArray(summary?.outstanding) ? summary.outstanding.map(String) : [];
+  const mintedHere = new Map(minted.map((e) => [e.qid, e]));
+  const refusedHere = outstanding.filter((q) => mintedHere.has(q));
+  if (refusedHere.length) {
+    let cur = supp;
+    try { cur = JSON.parse(readFileSync(suppPath, "utf8")); } catch { /* the in-memory plan is what was written */ }
+    const gone = new Set(refusedHere);
+    cur = withRejected({ ...cur, entries: (Array.isArray(cur?.entries) ? cur.entries : []).filter((e) => !gone.has(e?.qid)) },
+      // The markets and goods ride on the row: the ask ledger keeps one ask per (issue, proposal), and the compact
+      // proposal alone would fold the same question refused for several markets into one ask naming none.
+      refusedHere.map((q) => { const e = mintedHere.get(q); return { issue: OUTSTANDING_REASON, proposal: { ...compactProposal(e),
+        ...(Array.isArray(e?.regions) && e.regions.length ? { regions: e.regions.map(String).slice(0, 200) } : {}),
+        ...(Array.isArray(e?.goods_text) && e.goods_text.length ? { goods_text: e.goods_text.map((g) => String(g).slice(0, 80)).slice(0, 20) } : {}) } }; }),
+      { ts: new Date().toISOString(), origin: "propose-tool" });
+    mkdirSync(dirname(suppPath), { recursive: true });
+    writeFileSync(`${suppPath}.tmp`, JSON.stringify(cur, null, 2) + "\n");
+    renameSync(`${suppPath}.tmp`, suppPath);
+  }
+
   // read the results BACK FROM THE BAND — the reasoning payload is never model-transcribed
   const results = {};
   try {
     const band = JSON.parse(readFileSync(outPath, "utf8"));
     const blocks = Array.isArray(band) ? band : [];
     for (const b of blocks) {
-      if (!b || typeof b !== "object" || !b.qid || !qids.includes(b.qid)) continue;
+      if (!b || typeof b !== "object" || !b.qid || !(qids.includes(b.qid) || reusedHeld.includes(b.qid))) continue;
       results[b.qid] = {
         state: b.state ?? null,
         total_hits: b.total_hits ?? null,
@@ -517,5 +579,5 @@ export async function proposeSupplemental(params, tctx, deps) {
     }
   } catch { /* band unreadable — the executor summary still crosses */ }
 
-  return { type: "text", text: JSON.stringify({ minted: minted.map((e) => e.qid), reused, ...(enrichedQids.length ? { enriched: enrichedQids } : {}), ...(conflicts.length ? { conflict: conflicts } : {}), rejected, ...(excludedHouse.length ? { excluded_house_element: excludedHouse } : {}), ...(narrowed.length ? { narrowed } : {}), executed: qids.length > 0, summary, results }, null, 2) };
+  return { type: "text", text: JSON.stringify({ minted: minted.map((e) => e.qid).filter((q) => !refusedHere.includes(q)), reused, ...(enrichedQids.length ? { enriched: enrichedQids } : {}), ...(conflicts.length ? { conflict: conflicts } : {}), rejected, ...(outstanding.length ? { outstanding } : {}), ...(held.length ? { held } : {}), ...(outstanding.length || held.some((h) => h.decision === "outstanding") ? { outstanding_note: OUTSTANDING_NOTE } : {}), ...(reusedHeld.length ? { held_answer_kept: reusedHeld } : {}), ...(excludedHouse.length ? { excluded_house_element: excludedHouse } : {}), ...(narrowed.length ? { narrowed } : {}), executed: qids.length > 0, summary, results }, null, 2) };
 }

package/driver/findings-model.mjs

@@ -1534,7 +1534,7 @@ function validateNetRequired(f, ord, mode) {
   if (f.ruled_out === true) return;                                      // its ground is ruled_out_reason
   if (!POSITION_REQUIRED_DISPOSITIONS.includes(f.disposition)) return;   // withdrawn — see the const's doc block
   if (typeof f.net === "string" && f.net.trim()) return;
-  throw new Error(`finding_net_missing:${ord} (EVERY finding a reader sees carries the one-clause net — it is the ONLY per-finding summary the report has: the card leads with it, the grouped-negative line states it, the MCP brief lists the finding by it. Name the legal risk driver, then the FACT that conditions it. Length is the renderer's problem, not yours)`);
+  throw new Error(`finding_net_missing:${ord} (EVERY finding a reader sees carries the net — it is the ONLY per-finding summary the report has: the card leads with it, the grouped-negative line states it, the MCP brief lists the finding by it.)`);
 }
 
 // ── requirement 2 — the label follows the argument ───────────────────────────────────────────────
@@ -1734,9 +1734,9 @@ export function netChainMarkers(s) {
 function validateNet(f, ord, mode) {
   if (f.net == null) return;   // absent ⇒ v6 has already thrown; below v6 the card falls back as it always did
   if (typeof f.net !== "string" || !f.net.trim())
-    throw new Error(`finding_net_invalid:${ord} (net is the one-clause read — a non-empty string, or omit it)`);
+    throw new Error(`finding_net_invalid:${ord} (net is a non-empty string, or omit it)`);
   if (PRESCRIPTION_RE.test(f.net))
-    throw new Error(`finding_net_prescriptive:${ord} (the one-clause read carries FACTS AND ASSESSMENT, never an action prescription — the reader is a lawyer who layers their own advice on top; state the risk and the fact that conditions it, and let the typed actions register carry what a human must do)`);
+    throw new Error(`finding_net_prescriptive:${ord} (the read carries FACTS AND ASSESSMENT, never an action prescription — the reader is a lawyer who layers their own advice on top; let the typed actions register carry what a human must do)`);
   validateNetShape(f, ord, mode);
   f.net = f.net.trim();
 }
@@ -1805,7 +1805,7 @@ function validateNetShape(f, ord, mode) {
   if (!POSITION_REQUIRED_DISPOSITIONS.includes(f.disposition)) return;   // withdrawn — see above
   const markers = netChainMarkers(f.net);
   if (!markers.length) return;
-  throw new Error(`findings_net_chained:${ord} (the finding sentence is a CONCLUSION, not a chain — this net carries ${markers.join(" and ")}. Answer the one question a reader asks of this finding: is this a problem for me. Name the parties and the territory and state the outcome as a likelihood ("Veltra Labs' registered VELTRA is more likely than not to prevail against VELTRA PHARMA in the United States."). Then MOVE the chain's clauses — territories, the goods paraphrase, the owner's business, status and use history — into legal_position and practical_position, in full: this is a relocation, never a compression, and a net that got shorter because the reasoning got thinner is the wrong fix. There is no length cap)`);
+  throw new Error(`findings_net_chained:${ord} (the finding sentence is a CONCLUSION, not a chain — this net carries ${markers.join(" and ")}. Answer the one question a reader asks of this finding: is this a problem for me. Name the parties and the territory and state the outcome as a likelihood. Then MOVE the chain's clauses — territories, the goods paraphrase, the owner's business, status and use history — into legal_position and practical_position, in full: this is a relocation, never a compression, and a net that got shorter because the reasoning got thinner is the wrong fix.)`);
 }
 
 // The framework's own inputs, where it states a method. A finding with a band is a rated conflict and
@@ -2642,3 +2642,15 @@ export function blankForeignRecordLinks(doc, origins) {
   });
   return { doc: { ...doc, findings }, blanked, kept };
 }
+
+/**
+ * THE TOP-LEVEL KEYS A FINDINGS DOCUMENT OF THIS schema_version MAY CARRY — the ladder the parsers hold it to,
+ * read off the version as they read it. Exported for the synthesis transport, which reads a correction's
+ * list-less findings object as registers only where every key it carries is on the STORED record's own ladder:
+ * a key that ladder does not allow is refused either way, and it must meet the refusal it always met. Derived
+ * from the ladder above, never copied, for the reason FINDING_KEYS_CURRENT is.
+ */
+export function topKeysForVersion(schemaVersion) {
+  const v = typeof schemaVersion === "number" ? schemaVersion : 1;
+  return [...topKeysFor({ v4: v >= 4, v5: v >= 5, v6: v >= 6, v7: v >= 7 })];
+}

package/driver/floor-duty.mjs

@@ -244,6 +244,15 @@ export function floorDutyBlock(artifact, { armed = false } = {}) {
   };
 }
 
+/**
+ * THE FLOOR'S GAP POSITIVELY CLOSED, judged as `floorDutyBlock` judges it: the floor is armed, its account was
+ * computed, and no floor is left undischarged. An account that is absent, unreadable or not computable is no proof
+ * that the gap closed, so it is false here, where `floorDutyBlock` is null for the same account. PURE.
+ */
+export function floorDutyClosed(artifact, { armed = false } = {}) {
+  return armed === true && artifact?.computable === true && !((artifact?.undischarged_by_seat ?? 0) > 0);
+}
+
 export const FLOOR_DUTY_EVENT_FIELDS = ["floors", "accounted", "named_without_ground", "unanswered"];
 
 /** The run.jsonl row. `computable:false` carries its reason and NO counts — a zero here would read as

package/driver/gate-metrics.mjs

@@ -148,6 +148,10 @@ export function scoredFetched(runDir) {
   // un-normalised join here would miss ALL of them, not some — and a total miss reads as a clean
   // `fetched: 0`, which is this metric's alert, not its absence.
   const lines = readJson(join(runDir, "register-hit-list.json"))?.lines;
+  // NOT COMPUTED WHERE THE CODES ARE NOT THERE. The reading step is not asked for fate codes, and a list whose
+  // lines carry none says nothing about what judgment opened: read as a measurement, every scored finding would
+  // count as unfetched, an alarm about nothing. It says it could not be computed instead.
+  if (Array.isArray(lines) && lines.length && !lines.some((l) => l?.fate != null)) return { notComputed: "the hit list carries no fate codes" };
   if (Array.isArray(lines)) {
     // THREE STATES, NOT TWO, and the third is the one an earlier cut of this got wrong. A line the run
     // deliberately did not open (`NOT_PICKED`) leaves the denominator. A line whose fate this file does
@@ -292,7 +296,9 @@ export function computeGateMetrics(runDirs) {
   for (const d of runDirs) {
     const dr = deferralsRendered(d); if (dr) { agg.deferralsRendered.num += dr.rendered; agg.deferralsRendered.den += dr.total; }
     const sk = skepticConsumed(d);  if (sk) { agg.skepticConsumed.num += sk.consumed; agg.skepticConsumed.den += sk.total; }
-    const sf = scoredFetched(d);    if (sf) { agg.scoredFetched.num += sf.fetched;   agg.scoredFetched.den += sf.total; }
+    const sf = scoredFetched(d);
+    if (sf?.notComputed) agg.scoredFetched.notComputed = (agg.scoredFetched.notComputed ?? 0) + 1;
+    else if (sf) { agg.scoredFetched.num += sf.fetched;   agg.scoredFetched.den += sf.total; }
     const ct = clientTierMatch(d);  if (ct) { agg.clientTierMatch.num += ct.match;   agg.clientTierMatch.den += ct.total; }
     const lt = lintFirstPassTax(d); if (lt) { lintTaxRuns++; lintTaxFailures += lt.initialFailures; if (!lt.initialFailures) lintCleanFirstPass++; }
     const dg = documentGrowth(d);   if (dg) { growthRuns++; growthTrips += dg.count; }

package/driver/gateway.mjs

@@ -36,7 +36,7 @@ import { MODEL_FILE as FRAME_DIFF_MODEL_FILE, PROSE_FILE as FRAME_DIFF_PROSE_FIL
 import { MATTER_CONTEXT_FILE } from "./matter-frame-record.mjs";
 import { MODEL_FILE as VARIANT_MODEL_FILE, PROSE_FILE as VARIANT_PROSE_FILE } from "./clearance-variants-record.mjs";
 import { PROSE_FILE as REPORT_OVERVIEW_FILE } from "./report-overview-record.mjs";
-import { NARRATIVE_FILE, FINDINGS_FILE, refusalsFor } from "./synthesis-record.mjs";
+import { NARRATIVE_FILE, FINDINGS_FILE, refusalsFor, synthesisCallPaths } from "./synthesis-record.mjs";
 import { FINDINGS_FILE as REGISTER_FINDINGS_FILE, refusalsFor as registerDigestRefusalsFor } from "./register-digest-record.mjs";
 
 // artifact basename -> the tool that is now its only writer. A repair for one of these is a CALL, never a
@@ -2277,7 +2277,7 @@ export function correctiveMessage(baseMessage, attempt, lastFail, expectFile, {
       `\n\nCORRECTION: ${budget}${requiredFileClause(inner, { names, toolWritten })}`;
   return baseMessage +
     `\n\nCORRECTION: your previous attempt failed file validation (${inner}). ${budget}Re-do the task and make sure ` +
-    `${correctionHint(inner, { gridLedgerName: gridLedgerNameFor(expectFile), supplementalLane, undispatchable: frameDiffUndispatchable(expectFile, inner) })}. ` +
+    `${correctionHint(inner, { gridLedgerName: gridLedgerNameFor(expectFile), supplementalLane, undispatchable: frameDiffUndispatchable(expectFile, inner), heldRecord: heldSynthesisRecord(files) })}. ` +
     requiredFileClause(inner, { names, toolWritten });
 }
 
@@ -2362,7 +2362,22 @@ export function frameDiffUndispatchable(expectFile, lastFail = "framediff_direct
 // clearance writer's.
 const CLEARANCE_FINDINGS_TOKEN_RE = /(?<!knockout_|knockoutassess_)findings?_/;
 
-export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.json", supplementalLane = false, undispatchable = [], toolWritten = null } = {}) {
+// THE WRITER'S RETRY, WHEN THE DRIVER HOLDS ITS RECORD. A save the tool accepted can still fail the stage's own check
+// of the written files, and the driver then holds the record that save left: the retry sends only the change, in the
+// patch the follow-ups above it ask for. A record nobody saved yet, or one whose version is being replaced, still
+// takes the complete save.
+const HELD_RECORD_RETRY = "Fix exactly that in ONE `record_synthesis` PATCH call, sending only the change: `findings_patch` carrying the complete corrected finding object(s), each with the `ordinal` it replaces, and `findings` carrying any register you corrected, complete, and never a `findings[]` list; leave the narrative prose unchanged";
+const VERSION_FAILURE_RE = /finding_legacy_scale_forbidden|schema_version/;
+/**
+ * Does the driver hold an accepted synthesis record for the run these files belong to? Read from either of the files
+ * the writer's call renders: the stage's own expected file is the narrative, and a caller may name the findings.
+ */
+export const heldSynthesisRecord = (files) => {
+  const f = (Array.isArray(files) ? files : [files]).find((x) => typeof x === "string" && [NARRATIVE_FILE, FINDINGS_FILE].includes(basename(x)));
+  return Boolean(f) && existsSync(synthesisCallPaths(dirname(f)).accepted);
+};
+
+export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.json", supplementalLane = false, undispatchable = [], toolWritten = null, heldRecord = false } = {}) {
   // The repair act, for the hints that name one. Kept to a single sentence and a single decision so a
   // new hint has one thing to append rather than a branch to reproduce.
   const resaveClause = toolWritten
@@ -2457,8 +2472,9 @@ export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.jso
       `composite/level/dispute_type are RETIRED and forbidden), owner.registrations[] (ONE entry per ` +
       `registration — never overwrite or transpose another's facts; a finding with no fetched record → []), the four ` +
       `meters as {token, basis} (basis = verified-from-record | inferred-from-signal), quadrant {x,y} in [0,1], a ` +
-      `typed source, a disposition, and a unique 1-based ordinal. The failed check was: ${tok}.${extra} Fix exactly that, re-save ` +
-      `the COMPLETE findings.json, and leave the narrative prose unchanged`;
+      `typed source, a disposition, and a unique 1-based ordinal. The failed check was: ${tok}.${extra} ` +
+      (heldRecord && !VERSION_FAILURE_RE.test(lastFail) ? HELD_RECORD_RETRY
+        : `Fix exactly that, re-save the COMPLETE findings.json, and leave the narrative prose unchanged`);
   } else if (/coverage_status_offenum/.test(lastFail)) {
     // D1 — the off-enum PROSE Status cell (distinct from coverage_status_invalid, which is the JSON
     // mirror's token): the defect lives in register-findings.md's own Coverage-ledger table, so the
@@ -2827,8 +2843,7 @@ export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.jso
       ? diagnosis +
         `On this run the TOOLS own every band block: if the collapsed slice belongs to a DICTATED plan entry ` +
         `(it carries a qid from the frozen plan), close it by calling register_execute_plan ONCE with the exact ` +
-        `{"plan_path", "axis", "output_path"} from your stage instructions — that is the tool's whole call form ` +
-        `(it takes no per-qid argument); it re-runs this axis's dictated entries and refreshes their blocks, ` +
+        `{"plan_path", "axis", "output_path"} from your stage instructions; it re-runs this axis's dictated entries and refreshes their blocks, ` +
         `qid-stamped. If the collapsed slice ` +
         `was a judgment addition, RE-PROPOSE that EXACT slice through register_propose_supplemental with the same ` +
         `predicate, term(s), nice_classes and regions — the tool re-executes it and merges the corrected block ` +
@@ -2878,9 +2893,8 @@ export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.jso
       `the bridge killed it, so the band was never written. This is NOT a missing-structure defect and ` +
       `NOT something you did wrong. Call register_execute_plan ONCE more with the exact ` +
       `{"plan_path", "axis", "output_path"} from your stage instructions. If it is killed again, do ` +
-      `NOT author band blocks by hand and do NOT narrate coverage you did not get — record the timeout ` +
-      `in your .md, state the scope you attempted, and flag CROSS-CHECK REQUIRED. That note is the ` +
-      `correct answer to a tool that will not return, and it is what the reader needs`;
+      `NOT author band blocks by hand and do NOT narrate coverage you did not get — the driver's own call ` +
+      `log records that the call never returned`;
   } else if (/named_band_missing/.test(lastFail)) {
     // 2026-07-14 (copper-keystone): the unit's .md narrated success but the band file was NEVER WRITTEN —
     // the model skipped its one register_execute_plan call and fabricated the narrative. Unlike the
@@ -3516,7 +3530,7 @@ export function warmPatchMessage(lastFail, expectFile, { supplementalLane = fals
     const band = join(dirname(files[0]), basename(files[0]).replace(/\.md$/i, "-band.json"));
     return `You are RESUMING your own session for this stage — your prior work and inputs are already in your context. Do NOT redo your digest prose (${names} already passed validation).\n` +
       `Your register tool call WAS MADE and never returned — it was still running when the bridge killed it, so ${band} was never written. Nothing about your turn was wrong. Call register_execute_plan ONCE more with the exact {"plan_path", "axis", "output_path"} from your original stage instructions (output_path = ${band}), then stop.\n` +
-      `If it is killed again: do NOT author band blocks by hand and do NOT narrate coverage you did not obtain. Record the timeout in your .md, state the scope you attempted, and flag CROSS-CHECK REQUIRED. That is the correct answer to a tool that will not return.`;
+      `If it is killed again: do NOT author band blocks by hand and do NOT narrate coverage you did not obtain. The driver's own call log records that the call never returned.`;
   }
   // Sibling-JSON defects (WS-A coverage mirror / common-law grid): the FINDINGS file already passed
   // its prose checks — telling the model to rewrite it "in full" on a patch turn risks degrading
@@ -3616,7 +3630,7 @@ export function warmPatchMessage(lastFail, expectFile, { supplementalLane = fals
       ? `Do NOT redo the work from scratch. This stage's own output is the driver's — it is rendered from your \`${outIsToolWritten.tool}\` call and you hold no tool that writes it, so there is nothing there for you to rewrite or protect.`
       : `Do NOT redo the work from scratch, and do NOT rewrite ${names || "the findings file"} (it already passed validation).`;
     return `You are RESUMING your own session for this stage — your prior work and inputs are already in your context. ${standsClause}\n` +
-      `Your saved ${sibling} failed validation (${lastFail}). Fix exactly this: ensure ${correctionHint(lastFail, { gridLedgerName: gridLedgerNameFor(files), supplementalLane, undispatchable: frameDiffUndispatchable(files, lastFail) })}.\n` +
+      `Your saved ${sibling} failed validation (${lastFail}). Fix exactly this: ensure ${correctionHint(lastFail, { gridLedgerName: gridLedgerNameFor(files), supplementalLane, undispatchable: frameDiffUndispatchable(files, lastFail), heldRecord: heldSynthesisRecord(files) })}.\n` +
       `Re-save the COMPLETE corrected JSON at ${sib}. Do not stop until it exists and is valid.`;
   }
   // — A BLIND-FRAME REPAIR IS A TOOL CALL, NOT A FILE WRITE, and this branch is what stops the two
@@ -3668,7 +3682,7 @@ export function warmPatchMessage(lastFail, expectFile, { supplementalLane = fals
         // DIRECTIVES again, which is the 2026-07-29 reopen loss. Caught by frame-diff-model.test.mjs's
         // cardinality pin, which asserts the warm path carries the full list without the caller passing
         // anything.
-        : `What you sent did not pass (${lastFail}). Fix exactly this: ensure ${correctionHint(lastFail, { supplementalLane, undispatchable: frameDiffUndispatchable(files, lastFail), toolWritten: toolWritten.tool })}.\n`) +
+        : `What you sent did not pass (${lastFail}). Fix exactly this: ensure ${correctionHint(lastFail, { supplementalLane, undispatchable: frameDiffUndispatchable(files, lastFail), toolWritten: toolWritten.tool, heldRecord: heldSynthesisRecord(files) })}.\n`) +
       `Call \`${toolWritten.tool}\` with the values from the work already in your context — never by writing or editing any file. ` +
       `Do not stop until the tool accepts the call.`;
   }
@@ -3688,7 +3702,7 @@ export function warmPatchMessage(lastFail, expectFile, { supplementalLane = fals
   }
   const defective = failingTarget(lastFail, files) ?? files[0] ?? null;
   return `You are RESUMING your own session for this stage — your prior work and inputs are already in your context. Do NOT redo the work from scratch.\n` +
-    `Your saved ${defective ? rel(defective) : names || "output"} failed validation (${lastFail}). Fix exactly this: ensure ${correctionHint(lastFail, { gridLedgerName: gridLedgerNameFor(files), supplementalLane, undispatchable: frameDiffUndispatchable(files, lastFail) })}.\n` +
+    `Your saved ${defective ? rel(defective) : names || "output"} failed validation (${lastFail}). Fix exactly this: ensure ${correctionHint(lastFail, { gridLedgerName: gridLedgerNameFor(files), supplementalLane, undispatchable: frameDiffUndispatchable(files, lastFail), heldRecord: heldSynthesisRecord(files) })}.\n` +
     editRepairTail(defective || names || "the stage output");
 }