clearotron 0.4.1 → 0.5.0-beta.0

package/driver/repair-composers.mjs

@@ -53,6 +53,7 @@ import { basename } from "node:path";
 // this file would trade locality for nothing: what was missing was never their location, it was that
 // nothing enumerated them, so the guard could not walk them. They are imported and registered.
 import { buildFrameReopenFollowup, buildEscalationFollowup, buildEnvelopeCloseFollowup, buildFrameReopenRetryMessage, DECIDE_WAITING_FAMILIES } from "./stages.mjs";
+import { refutationStandingLines, refutationOpenItemsLine, REFUTATION_RECORDING_LINES } from "./stages.mjs";
 import { buildReconcileFollowup } from "./recall-reconciliation.mjs";
 import { buildFlushFollowup } from "./digest-queue.mjs";
 
@@ -88,18 +89,123 @@ const SAMPLE_PATHS = Object.freeze({
   commonLawGridHalf: (h) => `grid-ledger-${h}.json`, registerUnit: (a) => `units/${a}.md`,
 });
 
+// ── THE CORRECTION'S RULES AND STEPS, ONE TEXT FOR BOTH CORRECTIONS ──────────────────────────────────
+//
+// The first correction after the full review and the one correction after the review of a delivery-check
+// repair carry the same rules and steps, from the narrowing rule through the placement rulings. They live
+// here once, so the two corrections cannot drift apart; the first correction's text is byte-identical to
+// what it was before they moved.
+const KNOCK_ON = `If applying a flag genuinely REQUIRES changing a finding outside that list — a knock-on the reviewer did not see — make the change and say which one and why in the "corrections" note. A silent edit outside the scope is the one thing this instruction forbids; a reasoned one is not.`;
+// ── THE REVIEW AFTER A REPAIR: HOW ITS LIST IS RENDERED FROM VALUES ─────────────────────────────────────
+//
+// `repair-scope.mjs listForReview` computes the changes and the statements resting on them; these render each
+// one in the list's own words. A value is shown as written: text as text, anything else as JSON, an absent
+// value as null.
+const shown = (v) => (v == null ? "null" : typeof v === "string" ? v.replace(/\s+/g, " ").trim() : JSON.stringify(v));
+const lineState = (row) => (row ? `${row.state ?? ""}${row.note ? `: ${String(row.note).replace(/\s+/g, " ").trim()}` : ""}` : "null");
+const findingHead = (c) => (c.delivered != null ? `- Finding ${c.ordinal} (finding ${c.delivered} in findings.json):` : `- Finding ${c.ordinal}:`);
+const changeLine = (c) => {
+  if (c.kind === "finding") {
+    if (c.change === "added") return `${findingHead(c)} added by the repair: ${shown(c.after)}. It cites: ${shown(c.records)}.`;
+    if (c.change === "removed") return `${findingHead(c)} removed by the repair. It read: ${shown(c.before)}.`;
+    return `${findingHead(c)} ${c.fields.join(", ")} changed. Before: ${shown(c.before)}. After: ${shown(c.after)}. It cites: ${shown(c.records)}.`;
+  }
+  if (c.kind === "coverage") {
+    if (c.change === "added") return `- ${c.label}: added by the repair: ${lineState(c.after)}.`;
+    if (c.change === "removed") return `- ${c.label}: removed by the repair. It read: ${lineState(c.before)}.`;
+    return `- ${c.label}: before: ${lineState(c.before)}. After: ${lineState(c.after)}.`;
+  }
+  if (c.kind === "section") return `- the narrative's "${c.title}" section. Before: ${c.before} After: ${c.after}`;
+  return `- ${c.label}: before: ${shown(c.before)}. After: ${shown(c.after)}.`;
+};
+const restingLine = (r) => {
+  if (r.kind === "section") return `- the narrative's "${r.title}" section: ${r.text}`;
+  if (r.kind === "coverage-judgment") return `- the coverage judgment: ${shown(r.value)}`;
+  return `- ${r.label}, which names finding ${(r.ordinals ?? []).join(", ")}: ${r.text}`;
+};
+
+const correctiveRules = ({ narrative, findings, placement, rulingsTail }) => [
+  // ── — THE PASS THAT WRITES THE DEFECT ──────────────────────────────────
+  //
+  // Five verdict refusals in seven days, all one shape: a coverage or search-completion claim
+  // contradicted by the run's own records. FOUR of the five were introduced or worsened BY THIS
+  // PASS. one reviewer names it — "the REPLACEMENT for the frame-reopen sentence is now an
+  // overconfident global negative". another names it — "the corrective pass deleted the
+  // evidence and left the claim standing in a stronger and now factually wrong form".
+  // a third run's offending sentence entered at the corrective rewrite, measured at the
+  // sentence level: that pass removed one coverage assertion and wrote two, one of which refused
+  // the run.
+  //
+  // NOTHING ABOVE FORBADE ANY OF IT. The instruction constrains WHICH passages may move — "every
+  // passage the flags do not name stays byte-identical", plus the scope block below when the
+  // reviewer declared ordinals. It says nothing about what the REPLACEMENT may assert, and every
+  // one of these defects was an in-scope rewrite that broadened. The lead move — "correct the
+  // statement to what the evidence supports" — is itself a licence to rewrite, which is where the
+  // broadening happens.
+  //
+  // AND THE RESOLUTION WITH THE LINE ABOVE IS STATED, BECAUSE THE TWO LOOK LIKE THEY FIGHT.
+  // "Never softened" forbids adding hedges; "may never broaden" requires claiming less. A model
+  // handed both without the distinction will pick one. Narrowing is not hedging: stating a
+  // smaller claim, or removing the claim, is a correction; keeping the same claim and wrapping it
+  // in "may" or "appears to" is the hedge. Said in the text, not just here.
+  //
+  // NO DETECTOR, AND THAT IS DELIBERATE. The lexical gate this issue also proposed was measured
+  // over 32 delivered narratives and withdrawn: 31 of 32 fired, 141 sentences, and nine of twelve
+  // before/after run-pairs read identically, because a clearance narrative's job IS to state what
+  // was searched and what came back — the legitimate sentence and the defective one have the same
+  // shape and differ only in truth. The typed half of this class IS enforced structurally, on the
+  // corrective pair, by `evidenceClaimViolations` (pipeline.mjs ~10973) — but it reads
+  // `findings.json` meters, and a narrative sentence with no findings-side counterpart is invisible
+  // to it. That prose gap is conversion-era work, not an instruction. This is the instruction.
+  `A REPAIR MAY NARROW A CLAIM AND MAY NEVER BROADEN ONE. If a flagged statement is wrong because it claims too much, the correction states LESS: strike the claim, or replace it with the smaller claim the evidence actually carries. Never restate the same claim in different words, and never replace a specific sentence with a general one. NARROWING IS NOT HEDGING and the rule above still holds — claiming less is a correction; keeping the claim and wrapping it in "may", "appears to" or "broadly" is the hedge that is forbidden.`,
+  `THE COVERAGE ACCOUNT IS NOT YOURS TO REOPEN HERE. Do not introduce any statement about what was searched, counted, screened, finished, or came back empty that is not already in ${narrative}. That account was settled when you wrote it against the evidence in front of you; this pass has the reviewer's flags and not that evidence, so it is not in a position to widen it. Deleting a false coverage sentence is a correction. Replacing it with a different coverage sentence is not — strike it and say nothing in its place.`,
+  `IF YOU REMOVE THE SUPPORT FOR A CLAIM, THE CLAIM GOES WITH IT. Deleting the evidence and leaving the sentence standing does not make it safer, it makes it unsupported and therefore stronger than the record allows. A run was refused for exactly this.`,
+  `1. Correct the flagged narrative sections — send back ONLY the sections a flag names, and every section the flags do not name is left out and comes back byte-identical;`,
+  `2. mirror every correction into the finding objects the flags name (owner names, levels/composites, meters). A finding the review KILLS is not deleted: keep its object, set "disposition": "withdrawn" and add "withdrawn_reason": "<the review flag that killed it>". Add a "corrections": {"applied": true, "note": "<one line per flagged entity: corrected / withdrawn / no-change-because-…>"} marker inside the call's \`findings\` object.`,
+  // THE LINES THAT ARE NOT A FINDING. A coverage note, an action and the mark assessment carry no
+  // ordinal, so step 2 cannot reach them, and nothing said where a rewrite of one goes: seven such
+  // flags survived one clearance on the test box, each recorded as naming nothing (2026-09-11). The
+  // channel already existed — a PATCH copies a top-level register of the findings document through
+  // — and this names it. The coverage-account rule above forbids NEW claims about what was searched;
+  // rewording a note keeps its claims, and the text says so, or the seat reads the two as a conflict
+  // and does nothing, which is what it did.
+  `3. A flag about a line the reader sees that is NOT a finding — a coverage row's "note", an action's "text", or the mark assessment's "distinctiveness" or "connotation" — is applied in the same PATCH, inside the call's \`findings\` object beside the "corrections" marker: send the complete \`coverage\` array (every row, the unflagged ones exactly as you last sent them), the complete \`actions\` array, or the complete \`mark_assessment\` object, with the flagged line rewritten. A row left out of the array is a row deleted, so send every row. Rewording a coverage note is NOT reopening the coverage account: keep its area, its state and every fact it states, and change only how it says them. A flagged line you leave as written is named in the "corrections" note with the reason, as the flag names it — for example: the coverage line for "<area>": no-change-because …`,
+  // ── CONVERTED. `editRepairTail` stood here and ordered targeted Edits of
+  // both files. The seat holds no Edit for either any more — but the ECONOMICS that argued for a
+  // targeted edit are preserved rather than lost, which is why the call has a patch shape at all:
+  // measured full re-emission on four delivered clearances at 707.7 / 406.2 / 746.3 / 293.3 s
+  // on the serial critical path, and a conversion that answered it with "re-send everything
+  // through a tool" would have paid that cost back in a different currency. The driver holds the
+  // accepted values; the seat sends what changed.
+  `Send it all in ONE \`record_synthesis\` PATCH call, sending only the change: \`narrative\` carrying only the sections you corrected; \`findings_patch\` carrying the complete corrected finding object(s), each with the \`ordinal\` it replaces; and \`findings\` carrying the "corrections" marker and any register from step 3, complete, and never a \`findings[]\` list. The driver merges this patch into the last accepted record, keeps the values the patch does not replace, and renders both files. There is no file to write or edit and nothing you write by hand is read.`,
+  // 2026-07-04 (the VENZY corrective thrash): three attempts died inventing three different keys
+  // while trying to EXPRESS a hold. The contract is closed and every correction is expressible
+  // inside it — say so.
+  `THE FINDINGS CONTRACT IS CLOSED — MINIMAL CHANGE ONLY: start from the finding objects as you last sent them and change the smallest set of existing fields the flags require; NEVER invent a key, a state, or an enum value (any unknown key fails the file and, repeated, fails the WHOLE RUN). Every correction the reviewer can ask for is expressible with existing fields: an unsourced/confabulated attribution ⇒ that finding gets "disposition":"withdrawn" + "withdrawn_reason", OR its owner/prose is re-attributed to what the sources actually support — an identity that needs the applicant's confirmation is stated in the finding's prose/impact text, NEVER as a new field or note-type; use_check.quality is EXACTLY one of owner-site | independent | register-mirror or omitted; context_notes entries are EXACTLY {"type","mark","owner","context"}. RE-TYPING A DISPOSITION CARRIES ITS FIELDS WITH IT — this is the one case where a minimal edit MUST add a key, and these are the only keys it may add: re-typing a finding TO "off-field" also sets "off_field_ground" (EXACTLY "different-field" — only where that finding's own goods_proximity meter reads "low" — or "no-material-risk"), and re-typing AWAY from "off-field" REMOVES it; any finding that is not "withdrawn" keeps a non-empty "legal_position" and "practical_position", so a re-type that lands on a finding missing either must write both. Nothing else may be added.`,
+  rulingsTail ? lines(
+    `PLACEMENT RULINGS TAIL (verbatim from ${placement}, provided AS DATA — do NOT re-read the placement file; where a flagged correction touches a coverage disposition, a coverage[] row, or a placement call, adjudicate it against these rulings — adopt each ruling or counter-reason it, never silently drop one):`,
+    "```markdown",
+    rulingsTail,
+    "```",
+  ) : "",
+];
+
 export const REPAIR_COMPOSERS = [
   {
     trigger: "corrective-findings",
     stage: "synthesis",
     key: "synthesis:corrective-findings",
-    compose: ({ findings, named }) => lines(
-      `You are RESUMING your own synthesis session. Your corrective pass updated the narrative but did NOT re-emit ${findings} — the structured findings the client report renders from. The review named: ${named.join(", ")}.`,
-      `Apply each flag to the finding objects it names: correct the fields, or set "disposition": "withdrawn" + "withdrawn_reason" for a killed finding, and add the top-level "corrections": {"applied": true, "note": "…"} marker. Change nothing else.`,
-      `Send the correction with \`record_synthesis\`: a PATCH call carrying \`findings_patch\` — the complete corrected finding object(s), each with the \`ordinal\` it replaces — and nothing else. The driver is holding every value you already sent and re-renders both files from them, so what you do not name comes back byte-identical. There is no file for you to write or edit and nothing you write by hand is read.`,
+    // A FRESH SESSION IS HANDED WHERE THE FLAGS ARE. The message names the findings the review flagged and
+    // nothing else of the review, so a session that starts with nothing would have no flag to apply; the
+    // review's own file is named for it to open. `seniorEyeReview` is that file: the run's review on the first
+    // cycle, and the review after the delivery-check repair on the pass that applies it.
+    compose: ({ findings, named, seniorEyeReview }) => lines(
+      `This is a fresh session: your earlier synthesis is not in your context, and the driver holds the record it last accepted from you. Your corrective pass updated the narrative but did NOT re-emit ${findings} — the structured findings the client report renders from. The review named: ${named.join(", ")}. Its flags are in ${seniorEyeReview}; open it and ${findings} for the findings it names.`,
+      `Apply each flag to the finding objects it names: correct the fields, or set "disposition": "withdrawn" + "withdrawn_reason" for a killed finding, and add the "corrections": {"applied": true, "note": "…"} marker inside the call's \`findings\` object. Change nothing else.`,
+      `Send the correction with \`record_synthesis\`, sending only the change: a PATCH call carrying \`findings_patch\` — the complete corrected finding object(s), each with the \`ordinal\` it replaces — and \`findings\` carrying only the "corrections" marker, never a \`findings[]\` list; nothing else. The driver merges this patch into the last accepted record, keeps the values the patch does not replace, and renders both files. There is no file for you to write or edit and nothing you write by hand is read.`,
     ),
     samples: [{ name: "the standard re-emit demand", tail: "tool",
-      args: { findings: "findings.json", named: ["#1", "#4"] } }],
+      args: { findings: "findings.json", named: ["#1", "#4"], seniorEyeReview: "senior-eye-review.md" } }],
   },
   {
     trigger: "intake-asks-followup",
@@ -126,7 +232,7 @@ export const REPAIR_COMPOSERS = [
     stage: "synthesis",
     key: "synthesis:schema-downlevel",
     compose: ({ findings, declaredSv, frameworkKey, bandLabels }) => lines(
-      `You are RESUMING your own synthesis session. The findings file you emitted (${findings}) declares "schema_version": ${declaredSv}, but the dictation requires "schema_version": 4 — rated in the framework's band WORDS with a top-level "rated_under_framework": "${frameworkKey}", and NO composite/level/dispute_type keys (that scale is retired).`,
+      `This is a fresh session: your earlier synthesis is not in your context. The findings file you emitted (${findings}) declares "schema_version": ${declaredSv}, but the dictation requires "schema_version": 4 — rated in the framework's band WORDS with a top-level "rated_under_framework": "${frameworkKey}", and NO composite/level/dispute_type keys (that scale is retired).`,
       `Re-emit the COMPLETE record through \`record_synthesis\` at schema_version 4 — same findings, same judgments, each rated finding carrying "band" (EXACTLY one of: ${bandLabels.join(" / ")}) per the original dictation. Change nothing else. This one is a whole re-send rather than a patch, because the key set itself changes shape: there is no set of named findings to correct.`,
     ),
     // A WHOLE-FILE EMISSION WITH NO REPAIR TAIL, AND THE SITE SAYS WHY: the key set changes shape, so
@@ -139,12 +245,14 @@ export const REPAIR_COMPOSERS = [
     trigger: "actions-missing",
     stage: "synthesis",
     key: "synthesis:actions-missing",
-    compose: ({ findings }) => lines(
-      `You are RESUMING your own synthesis session. The findings file you emitted (${findings}) has no top-level "actions" array, but the dictation requires the ACTIONS REGISTER: ONE object per forward step your opinion names that a HUMAN must still take, each EXACTLY {"id","kind","text","ordinals"} (+ optional "deadline":{"kind","date"}) — kinds: conditions consent / coexistence-agreement / territorial-delimitation / goods-amendment / mark-modification / senior-clearance / proceeding-response / counsel-opinion-required; advisory client-fact / commercial-decision / monitoring / filing-routine.`,
-      `Add ONE top-level "actions": [...] key that registers every forward step your own narrative names ("actions": [] ONLY if the opinion genuinely demands nothing beyond ordinary filing). Same findings, same judgments — the findings themselves do not change.`,
-      `Send it with \`record_synthesis\` as a PATCH call carrying only "actions". The driver is holding every finding you already sent and re-renders from them, so nothing else moves. There is no file for you to write or edit.`,
+    // `narrative` is named because a fresh session has not read it, and the register it is asked for is the
+    // forward steps that narrative names.
+    compose: ({ findings, narrative }) => lines(
+      `This is a fresh session: your earlier synthesis is not in your context. The findings file you emitted (${findings}) has no top-level "actions" array, but the dictation requires the ACTIONS REGISTER: ONE object per forward step your opinion names that a HUMAN must still take, each EXACTLY {"id","kind","text","ordinals"} (+ optional "deadline":{"kind","date"}) — kinds: conditions consent / coexistence-agreement / territorial-delimitation / goods-amendment / mark-modification / senior-clearance / proceeding-response / counsel-opinion-required; advisory client-fact / commercial-decision / monitoring / filing-routine.`,
+      `Add ONE top-level "actions": [...] key that registers every forward step your own narrative (${narrative}) names ("actions": [] ONLY if the opinion genuinely demands nothing beyond ordinary filing). Same findings, same judgments — the findings themselves do not change.`,
+      `Send it with \`record_synthesis\` as a PATCH call carrying only "actions". The driver merges this patch into the last accepted record, keeps the values the patch does not replace, and renders both files. There is no file for you to write or edit.`,
     ),
-    samples: [{ name: "the actions register demand", tail: "tool", args: { findings: "findings.json" } }],
+    samples: [{ name: "the actions register demand", tail: "tool", args: { findings: "findings.json", narrative: "narrative.md" } }],
   },
   {
     trigger: "corrective",
@@ -162,77 +270,15 @@ export const REPAIR_COMPOSERS = [
         `SCOPE — THE REVIEWER DECLARED WHICH FINDINGS ITS FLAGS ARE ABOUT, AND THIS IS THE COMPLETE LIST: ${
           scope.ordinals.length ? scope.ordinals.map((o) => `#${o}`).join(", ") : "(none — every flag is about the document, not a finding)"}.`,
         `Change ONLY those finding objects and ONLY the narrative passages that discuss them. EVERY OTHER FINDING OBJECT IN ${findings} MUST COME BACK BYTE-IDENTICAL — do not re-derive it, do not re-word it, do not re-order its keys. The driver compares them and records anything that moved.`,
-        `If applying a flag genuinely REQUIRES changing a finding outside that list — a knock-on the reviewer did not see — make the change and say which one and why in the "corrections" note. A silent edit outside the scope is the one thing this instruction forbids; a reasoned one is not.`,
+        KNOCK_ON,
       ) : "";
       return lines(
         // — RULING 2026-08-09: "add caveat" is DELETED, not softened. A repair has exactly
         // four moves and there is no fifth. The standing outward-language rule governs the REPAIR path
         // exactly as it governs a first draft, and this instruction was the one place the engine invited
         // a hedge into a deliverable. It fired on 4 of 4 delivered clearances in the 2026-08-09 round.
-        `You are RESUMING your own synthesis session — your narrative and all inputs are already in your context; do NOT redo it from scratch. The independent refutation flagged the corrections below. Apply them (minimum-change per flag — correct the statement to what the evidence supports, demote the tier, remove the sentence, or verify-flag for re-check) to BOTH deliverables. A caveat, hedge, qualifier or disclaimer is NEVER a repair: an unsupported statement is corrected or it is removed, never softened.`,
-        // ── — THE PASS THAT WRITES THE DEFECT ──────────────────────────────────
-        //
-        // Five verdict refusals in seven days, all one shape: a coverage or search-completion claim
-        // contradicted by the run's own records. FOUR of the five were introduced or worsened BY THIS
-        // PASS. one reviewer names it — "the REPLACEMENT for the frame-reopen sentence is now an
-        // overconfident global negative". another names it — "the corrective pass deleted the
-        // evidence and left the claim standing in a stronger and now factually wrong form".
-        // a third run's offending sentence entered at the corrective rewrite, measured at the
-        // sentence level: that pass removed one coverage assertion and wrote two, one of which refused
-        // the run.
-        //
-        // NOTHING ABOVE FORBADE ANY OF IT. The instruction constrains WHICH passages may move — "every
-        // passage the flags do not name stays byte-identical", plus the scope block below when the
-        // reviewer declared ordinals. It says nothing about what the REPLACEMENT may assert, and every
-        // one of these defects was an in-scope rewrite that broadened. The lead move — "correct the
-        // statement to what the evidence supports" — is itself a licence to rewrite, which is where the
-        // broadening happens.
-        //
-        // AND THE RESOLUTION WITH THE LINE ABOVE IS STATED, BECAUSE THE TWO LOOK LIKE THEY FIGHT.
-        // "Never softened" forbids adding hedges; "may never broaden" requires claiming less. A model
-        // handed both without the distinction will pick one. Narrowing is not hedging: stating a
-        // smaller claim, or removing the claim, is a correction; keeping the same claim and wrapping it
-        // in "may" or "appears to" is the hedge. Said in the text, not just here.
-        //
-        // NO DETECTOR, AND THAT IS DELIBERATE. The lexical gate this issue also proposed was measured
-        // over 32 delivered narratives and withdrawn: 31 of 32 fired, 141 sentences, and nine of twelve
-        // before/after run-pairs read identically, because a clearance narrative's job IS to state what
-        // was searched and what came back — the legitimate sentence and the defective one have the same
-        // shape and differ only in truth. The typed half of this class IS enforced structurally, on the
-        // corrective pair, by `evidenceClaimViolations` (pipeline.mjs ~10973) — but it reads
-        // `findings.json` meters, and a narrative sentence with no findings-side counterpart is invisible
-        // to it. That prose gap is conversion-era work, not an instruction. This is the instruction.
-        `A REPAIR MAY NARROW A CLAIM AND MAY NEVER BROADEN ONE. If a flagged statement is wrong because it claims too much, the correction states LESS: strike the claim, or replace it with the smaller claim the evidence actually carries. Never restate the same claim in different words, and never replace a specific sentence with a general one. NARROWING IS NOT HEDGING and the rule above still holds — claiming less is a correction; keeping the claim and wrapping it in "may", "appears to" or "broadly" is the hedge that is forbidden.`,
-        `THE COVERAGE ACCOUNT IS NOT YOURS TO REOPEN HERE. Do not introduce any statement about what was searched, counted, screened, finished, or came back empty that is not already in ${narrative}. That account was settled when you wrote it against the evidence in front of you; this pass has the reviewer's flags and not that evidence, so it is not in a position to widen it. Deleting a false coverage sentence is a correction. Replacing it with a different coverage sentence is not — strike it and say nothing in its place.`,
-        `IF YOU REMOVE THE SUPPORT FOR A CLAIM, THE CLAIM GOES WITH IT. Deleting the evidence and leaving the sentence standing does not make it safer, it makes it unsupported and therefore stronger than the record allows. A run was refused for exactly this.`,
-        `1. Correct the flagged narrative sections — send back ONLY the sections a flag names, and every section the flags do not name is left out and comes back byte-identical;`,
-        `2. mirror every correction into the finding objects the flags name (owner names, levels/composites, meters). A finding the review KILLS is not deleted: keep its object, set "disposition": "withdrawn" and add "withdrawn_reason": "<the review flag that killed it>". Add a top-level "corrections": {"applied": true, "note": "<one line per flagged entity: corrected / withdrawn / no-change-because-…>"}.`,
-        // THE LINES THAT ARE NOT A FINDING. A coverage note, an action and the mark assessment carry no
-        // ordinal, so step 2 cannot reach them, and nothing said where a rewrite of one goes: seven such
-        // flags survived one clearance on the test box, each recorded as naming nothing (2026-09-11). The
-        // channel already existed — a PATCH copies a top-level register of the findings document through
-        // — and this names it. The coverage-account rule above forbids NEW claims about what was searched;
-        // rewording a note keeps its claims, and the text says so, or the seat reads the two as a conflict
-        // and does nothing, which is what it did.
-        `3. A flag about a line the reader sees that is NOT a finding — a coverage row's "note", an action's "text", or the mark assessment's "distinctiveness" or "connotation" — is applied in the same PATCH: send the complete top-level \`coverage\` array (every row, the unflagged ones exactly as you last sent them), the complete \`actions\` array, or the complete \`mark_assessment\`, with the flagged line rewritten. A row left out of the array is a row deleted, so send every row. Rewording a coverage note is NOT reopening the coverage account: keep its area, its state and every fact it states, and change only how it says them. A flagged line you leave as written is named in the "corrections" note with the reason, as the flag names it — for example: the coverage line for "<area>": no-change-because …`,
-        // ── CONVERTED. `editRepairTail` stood here and ordered targeted Edits of
-        // both files. The seat holds no Edit for either any more — but the ECONOMICS that argued for a
-        // targeted edit are preserved rather than lost, which is why the call has a patch shape at all:
-        // measured full re-emission on four delivered clearances at 707.7 / 406.2 / 746.3 / 293.3 s
-        // on the serial critical path, and a conversion that answered it with "re-send everything
-        // through a tool" would have paid that cost back in a different currency. The driver holds the
-        // accepted values; the seat sends what changed.
-        `Send it all in ONE \`record_synthesis\` PATCH call: \`narrative\` carrying only the sections you corrected, and \`findings_patch\` carrying the complete corrected finding object(s), each with the \`ordinal\` it replaces. The driver is holding everything else you sent and re-renders both files, so what you do not name is byte-identical by construction rather than by your care. There is no file to write or edit and nothing you write by hand is read.`,
-        // 2026-07-04 (the VENZY corrective thrash): three attempts died inventing three different keys
-        // while trying to EXPRESS a hold. The contract is closed and every correction is expressible
-        // inside it — say so.
-        `THE FINDINGS CONTRACT IS CLOSED — MINIMAL CHANGE ONLY: start from the finding objects as you last sent them and change the smallest set of existing fields the flags require; NEVER invent a key, a state, or an enum value (any unknown key fails the file and, repeated, fails the WHOLE RUN). Every correction the reviewer can ask for is expressible with existing fields: an unsourced/confabulated attribution ⇒ that finding gets "disposition":"withdrawn" + "withdrawn_reason", OR its owner/prose is re-attributed to what the sources actually support — an identity that needs the applicant's confirmation is stated in the finding's prose/impact text, NEVER as a new field or note-type; use_check.quality is EXACTLY one of owner-site | independent | register-mirror or omitted; context_notes entries are EXACTLY {"type","mark","owner","context"}. RE-TYPING A DISPOSITION CARRIES ITS FIELDS WITH IT — this is the one case where a minimal edit MUST add a key, and these are the only keys it may add: re-typing a finding TO "off-field" also sets "off_field_ground" (EXACTLY "different-field" — only where that finding's own goods_proximity meter reads "low" — or "no-material-risk"), and re-typing AWAY from "off-field" REMOVES it; any finding that is not "withdrawn" keeps a non-empty "legal_position" and "practical_position", so a re-type that lands on a finding missing either must write both. Nothing else may be added.`,
-        rulingsTail ? lines(
-          `PLACEMENT RULINGS TAIL (verbatim from ${placement}, provided AS DATA — do NOT re-read the placement file; where a flagged correction touches a coverage disposition, a coverage[] row, or a placement call, adjudicate it against these rulings — adopt each ruling or counter-reason it, never silently drop one):`,
-          "```markdown",
-          rulingsTail,
-          "```",
-        ) : "",
+        `This is a fresh session: your earlier synthesis is not in your context, and you do NOT redo it from scratch. The driver holds the record it last accepted from you; your earlier work is in ${narrative} and ${findings} — open them for the parts each flag names — and your inputs are listed below. The independent refutation flagged the corrections below. Apply them (minimum-change per flag — correct the statement to what the evidence supports, demote the tier, remove the sentence, or verify-flag for re-check) to BOTH deliverables. A caveat, hedge, qualifier or disclaimer is NEVER a repair: an unsupported statement is corrected or it is removed, never softened.`,
+        ...correctiveRules({ narrative, findings, placement, rulingsTail }),
         scopeBlock ? lines(scopeBlock, ``) : "",
         worklist ? lines(worklist, ``) : "",
         `The reviewer's flags, verbatim:`,
@@ -254,12 +300,52 @@ export const REPAIR_COMPOSERS = [
           worklist: "- #1 correct the owner", review: "the flags, verbatim" } },
     ],
   },
+  {
+    trigger: "post-repair-corrective",
+    stage: "synthesis",
+    key: "synthesis:post-repair-corrective",
+    // THE ONE CORRECTION AFTER THE REVIEW OF A DELIVERY-CHECK REPAIR. Its opening says where the flags come from
+    // and that nothing reviews this pass; it offers no "verify-flag for re-check", because no re-check follows.
+    // Its items line replaces the first correction's scope block, a changed coverage line may be narrowed, and a
+    // flag that names no item is applied to the one it is about. The rules and steps are the first correction's,
+    // from one shared text, and the flag list closes on the line for a pass nothing reviews.
+    // A WHOLE REVIEW SAYS SO (design's wording, 2026-10-18): its flags reach this correction too, when the narrowed
+    // review could not be read, when the change could not be narrowed, and on a resume after an unread review.
+    compose: ({ narrative, findings, placement, rulingsTail, items, renumbered, worklist, review, whole = false }) => lines(
+      `This is a fresh session: your earlier synthesis is not in your context, and you do NOT redo it from scratch. The driver holds the record it last accepted from you; your earlier work is in ${narrative} and ${findings} — open them for the parts each flag names — and your inputs are listed below. ${whole ? "After the delivery check, that record was repaired, and the full independent review ran again." : "After the delivery check, that record was repaired, and an independent review then read only what the repair changed and what rests on it."} It flagged the corrections below, and nothing reviews this pass again. Apply them (minimum-change per flag — correct the statement to what the evidence supports, demote the tier, or remove the sentence) to BOTH deliverables. A caveat, hedge, qualifier or disclaimer is NEVER a repair: an unsupported statement is corrected or it is removed, never softened.`,
+      // An empty list does not reuse the first correction's "every flag is about the document": here an unplaced flag
+      // may be about a finding, and the line below says how to apply one.
+      `THE FLAGS NAME THESE ITEMS: ${items?.length ? items.join(", ") : "(none named; apply each unplaced flag as described below)"}. Change only the items the flags are about and the narrative passages that discuss them. Everything else in the record stays as the driver last accepted it from you.`,
+      `For a coverage line the repair changed, a flag may ask for its state or its facts to change, not only its words. Make that change only where the line then claims less than it does now, as the narrowing rule below requires. This is the one exception to the rule below that the coverage account is not yours to reopen; every other coverage line keeps its area, its state and every fact it states.`,
+      `A flag that names no item is applied to the item it is about; name that item in the "corrections" note. If you cannot tell what the flag is about, change nothing for it and say so in the note.`,
+      renumbered ? `Where a flag's own words give a finding a different number from its [on: …], use the [on: …] number. It is the number in your record.` : "",
+      KNOCK_ON,
+      ...correctiveRules({ narrative, findings, placement, rulingsTail }),
+      worklist ? lines(worklist, ``) : "",
+      `The reviewer's flags, verbatim:`,
+      ``,
+      ``,
+      review,
+    ),
+    samples: [
+      { name: "flags on a coverage line and a finding, no placement tail", tail: "tool",
+        args: { narrative: "narrative.md", findings: "findings.json", placement: "placements.md", rulingsTail: "",
+          items: ["finding 2", "the coverage line for \"register / EU\""], renumbered: false,
+          worklist: "THE FLAGS, TYPED (2):", review: "the flags, verbatim" } },
+      { name: "a renumbered finding, a placement tail, and no item named", tail: "tool",
+        args: { narrative: "narrative.md", findings: "findings.json", placement: "placements.md", rulingsTail: "| axis | ruling |",
+          items: [], renumbered: true, worklist: "", review: "the flags, verbatim" } },
+      { name: "the flags of a whole review", tail: "tool",
+        args: { narrative: "narrative.md", findings: "findings.json", placement: "placements.md", rulingsTail: "",
+          items: [], renumbered: false, worklist: "", review: "the flags, verbatim", whole: true } },
+    ],
+  },
   {
     trigger: "verdict-recheck",
     stage: "narrative-refutation",
     key: "narrative-refutation:verdict-recheck",
     compose: ({ narrative, findings, seniorEyeReview, correctionsScope, appliedTable, restoredTable, evidenceTable, planAuditCarry }) => lines(
-      `You are RESUMING your own narrative-refutation session — your prior verdict, the narrative, and the source files you refuted against are already in your context; do NOT re-read them from scratch.`,
+      `This is a fresh session: your earlier refutation is not in your context, and you do NOT redo it from scratch. Your prior verdict and its flags are in ${seniorEyeReview} — open it first — and the source files you refuted against are listed below.`,
       // — WHEN THE SCOPE WAS DECLARED, THE RE-READ IS NARROWED TO IT. The recheck cost 270-510 s on
       // every measured run, and its whole job is to judge whether the corrections are RIGHT — not to
       // re-derive which parts of two long documents changed. The driver already knows: it holds the
@@ -304,9 +390,62 @@ export const REPAIR_COMPOSERS = [
           correctionsScope: { scoped: true, named: [1], moved: [4] },
           appliedTable: "| flag | outcome |", restoredTable: "", evidenceTable: "| finding | meter | what moved |", planAuditCarry: "plan-audit carry" } },
     ],
-    singleMember: "narrative-refutation has exactly one bespoke composer. Recorded so the census reds if "
-      + "the stage gains a second without this note being read — a guard proven at n=1 has proven "
-      + "nothing about ordering or interaction between two composers on one stage.",
+  },
+  {
+    trigger: "post-repair-review",
+    stage: "narrative-refutation",
+    key: "narrative-refutation:post-repair-review",
+    // THE REVIEW AFTER A DELIVERY-CHECK REPAIR. The first review stays whole; this one reads what the repair
+    // changed and every statement that rests on it, with the evidence to check both, and its flags go to one
+    // correction. VALUES IN: the list `repair-scope.mjs listForReview` computed from the writer's record before
+    // and after the repair. The standing tools and notes, the open-items check and the recording lines are the
+    // full review's own, read from one shared text in stages.mjs.
+    compose: ({ findings, changes, resting, renumbered, coverageChanged, evidence, registerOnly = false, job = {}, skepticFlags, frameReopenReceipt, floorDecisions = null }) => lines(
+      `This is a review of a repair, not a full review. Earlier in this run the narrative was reviewed in full, and the corrections that review raised went to the writer. The delivery check then found a fault, and the writer repaired the record.`,
+      `Review only what that repair changed, listed below under WHAT THE REPAIR CHANGED, and any statement elsewhere in the narrative or in the findings record, ${findings}, that rests on a changed item. Such a statement no longer holds if the change leaves it untrue, without its support, or incomplete.`,
+      `Everything else stands as this run's earlier reviews left it. Do not flag a statement that rests on no changed item.`,
+      `From your own manual, skills/narrative-refutation/SKILL.md, use only the checks that bear on these items. Its whole-report checks, its length target for a review and its expectation that a clean review is rare belong to the full review, not to this one. A clean result is a normal outcome here.`,
+      `Check each changed item against the evidence named for it, and each statement that rests on a changed item against the new values.`,
+      `Say what each flag is about. For a finding, put its number from the list below in \`on\`. For anything else, begin the flag's text with the item's name exactly as the list gives it, for example: the coverage line for "<area>".`,
+      renumbered ? `Where a finding below shows two numbers, put the first in \`on\`. The second is its number in findings.json.` : "",
+      `Your verdict is about the repair. CLEAR: what changed is sound, and every statement that rests on a changed item still holds. CONDITIONAL: a flag needs a correction. BLOCKING: the change makes the report unsafe to sign, under your manual's verdict logic.`,
+      `Your flags go to one correction pass by the writer, and nothing reviews that pass again. Make each fix exact.`,
+      ...refutationStandingLines({ registerOnly, job, floorDecisions }),
+      // A repair that rewrites coverage lines can drop an open item; when coverage is untouched, the full review
+      // already checked this.
+      coverageChanged ? refutationOpenItemsLine({ skepticFlags, frameReopenReceipt }) : "",
+      ...REFUTATION_RECORDING_LINES,
+      `WHAT THE REPAIR CHANGED. The driver worked this out from the writer's saved record before and after the repair. A value saved again unchanged is not listed.`,
+      ...(changes ?? []).map(changeLine),
+      resting?.length ? `WHAT RESTS ON THESE CHANGES, as it reads now. Check that each still holds:` : "",
+      ...(resting ?? []).map(restingLine),
+      `WHERE THE EVIDENCE IS:`,
+      evidence?.coverage ? `- For a coverage line: the run's coverage ledger, register-coverage-ledger.json, and the plan-execution check below.` : "",
+      evidence?.finding ? `- For a finding: the records it cites, through band_record, and its row in placements.json.` : "",
+      `- For a narrative section: the source files in your declared inputs, below.`,
+    ),
+    // NO REPAIR TAIL, DECLARED: like the re-check, this orders the reviewer's own review, recorded through its
+    // own tool, which the recording lines name.
+    samples: [
+      { name: "a repair that changed coverage lines only", tail: "none",
+        args: { findings: "findings.json", skepticFlags: "skeptic-flags.json", frameReopenReceipt: "frame-reopen.json",
+          changes: [{ kind: "coverage", change: "changed", label: "the coverage line for \"register / EU\"",
+            before: { state: "confirmed-clean", note: "searched in full" }, after: { state: "coverage-limited", note: "one class was not read" } },
+            { kind: "coverage", change: "added", label: "the coverage line for \"register / UK\"", after: { state: "not-searched", note: "outside the plan" } }],
+          resting: [{ kind: "section", title: "Verdict", text: "One conflict needs a decision." }, { kind: "coverage-judgment", value: { sufficient: true, reason: "the plan ran" } }],
+          renumbered: false, coverageChanged: true, evidence: { coverage: true, finding: false } } },
+      { name: "a prose section and a finding the fold renumbered", tail: "none",
+        args: { findings: "findings.json", skepticFlags: "skeptic-flags.json", frameReopenReceipt: "frame-reopen.json",
+          changes: [{ kind: "finding", change: "changed", ordinal: 7, delivered: 6, fields: ["band"], before: { band: "Moderate" }, after: { band: "Serious" },
+            records: { source_type: "register-vendor", resolved_link: "https://example.invalid/mark/1" } },
+            { kind: "section", change: "changed", title: "The spine", before: "The spine was the coined element.", after: "The spine is the coined element." }],
+          resting: [{ kind: "action", label: "the action \"a1\"", ordinals: [7], text: "Ask counsel about finding 7." }],
+          renumbered: true, coverageChanged: false, evidence: { coverage: false, finding: true } } },
+      { name: "a register-only run whose repair removed a finding", tail: "none",
+        args: { findings: "findings.json", registerOnly: true, skepticFlags: "skeptic-flags.json", frameReopenReceipt: "frame-reopen.json",
+          changes: [{ kind: "finding", change: "removed", ordinal: 3, delivered: null, before: { ordinal: 3, mark: "NOVA" } }],
+          resting: [], renumbered: false, coverageChanged: false, evidence: { coverage: false, finding: true } } },
+    ],
   },
   {
     trigger: "lint-repair",
@@ -315,17 +454,29 @@ export const REPAIR_COMPOSERS = [
     // delivery-tail stage failed its pre-delivery lint.
     stage: "*",
     key: "*:lint-repair",
-    compose: ({ label, file, toolWritten, failures }) => lines(
-      toolWritten
-        ? `You are RESUMING your own ${label} session — the driver wrote ${file} from your \`${toolWritten.tool}\` call, and the deterministic pre-delivery lint failed these checks on it:`
-        : `You are RESUMING your own ${label} session — ${file} is already written and the deterministic pre-delivery lint failed these checks on it:`,
-      ...failures.map((f) => `- ${f.detail || f.id}`),
+    // THE WRITER'S FORM names both files its call wrote: its faults can sit in the narrative or in a line the report
+    // composes from its findings record, and a fault in such a line is named by the finding that owns it, in the
+    // numbering its save takes.
+    compose: ({ label, file, toolWritten, failures, findings, narrative }) => lines(
+      toolWritten?.tool === "record_synthesis"
+        ? `This is a fresh session: your earlier synthesis work is not in your context. The driver wrote ${findings} and ${narrative} from your \`record_synthesis\` call. The deterministic pre-delivery checks found these faults in content rendered from that record:`
+        : toolWritten
+          ? `This is a fresh session: your earlier ${label} work is not in your context — the driver wrote ${file} from your \`${toolWritten.tool}\` call, and the deterministic pre-delivery lint failed these checks on it:`
+          : `This is a fresh session: your earlier ${label} work is not in your context — ${file} is already written and the deterministic pre-delivery lint failed these checks on it:`,
+      ...failures.map((f) => `- ${f.finding != null ? `finding ${f.finding}: ` : ""}${f.detail || f.id}`),
+      toolWritten?.tool === "record_synthesis" ? `Read ${findings} and ${narrative}, then correct the finding or narrative section that owns each fault.` : "",
       `Where a check quotes the fetched record's true value, correct the identifier to the record's value EXACTLY (the record is the only permitted source for registry identifiers).`,
       `Risk tiers and Level/Composite labels are COPIED from the findings values quoted in the check — never re-derive or re-word them.`,
       `Fix ONLY what the checks name; change nothing else.`,
-      toolWritten
-        ? `Apply the fix by calling \`${toolWritten.tool}\` AGAIN with the corrected values — the COMPLETE payload, not a patch, because the driver re-renders the whole artifact from what you send. You hold no Write or Edit tool for it and nothing you write by hand is read.`
-        : editRepairTail(file),
+      // THE WRITER'S SAVE MERGES A PATCH; EVERY OTHER TOOL HERE TAKES ITS WHOLE PAYLOAD. `record_synthesis`
+      // holds the record it last accepted and merges a patch into it, so the writer sends only the change, in
+      // the shape its correction message uses. The other tools a delivery repair reaches render their artifact
+      // from the call they are sent, so they keep the complete-payload line.
+      toolWritten?.tool === "record_synthesis"
+        ? `Apply the fix in ONE \`record_synthesis\` PATCH call, sending only the change: \`narrative\` carrying only the sections you corrected; \`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. The driver merges this patch into the last accepted record, keeps the values the patch does not replace, and renders both files. You hold no Write or Edit tool for it and nothing you write by hand is read.`
+        : toolWritten
+          ? `Apply the fix by calling \`${toolWritten.tool}\` AGAIN with the corrected values — the COMPLETE payload, not a patch, because the driver re-renders the whole artifact from what you send. You hold no Write or Edit tool for it and nothing you write by hand is read.`
+          : editRepairTail(file),
     ),
     // BOTH BRANCHES, AND THE CENSUS REQUIRES BOTH. This composer is the one that can hand a seat either
     // a tool order or a file-edit order depending on how its artifact is written, so a sample set
@@ -347,12 +498,19 @@ export const REPAIR_COMPOSERS = [
     // reported a defect in text no seat can be handed." The edit branch IS exercised — by the fixed
     // `samples` below, which is where the census checks branch coverage.
     samplesForStage: ({ stage, tool, file }) => [
-      { name: `${stage}'s own tool-written artifact`, tail: "tool", args: { label: stage, file, toolWritten: { tool }, failures: [{ id: "lint_1", detail: "a check the lint named" }] } },
+      { name: `${stage}'s own tool-written artifact`, tail: "tool", args: { label: stage, file, toolWritten: { tool }, findings: "findings.json", narrative: file,
+        failures: [{ id: "lint_1", detail: "a check the lint named" }] } },
     ],
     samples: [
       { name: "a tool-written artifact", tail: "tool",
         args: { label: "report-card", file: "report-cards/0.md", toolWritten: { tool: "record_report_card" },
           failures: [{ id: "rc_band_mismatch", detail: "band says CLEAR, findings say BORDERLINE" }] } },
+      // The writer's branch: its save merges a patch, so it is the one tool-written artifact told to send only
+      // the change.
+      { name: "the writer's record, which takes a patch", tail: "tool",
+        args: { label: "synthesis", file: "narrative.md", toolWritten: { tool: "record_synthesis" }, findings: "findings.json", narrative: "narrative.md",
+          failures: [{ id: "narrative_coverage_claim", detail: "a coverage line claims a slice the plan did not run" },
+            { id: "prescription-prose", finding: 2, detail: "the sentence composed from finding 2 recommends a filing" }] } },
       // THE SAMPLE MOVED STAGES RATHER THAN FLIPPING ITS SHAPE. It read
       // `{label:"synthesis", file:"narrative.md", toolWritten:null}`, and when the writer converted, the
       // sample-honesty arm fails it by name — narrative.md now has a row. Flipping this entry to
@@ -383,11 +541,11 @@ export const REPAIR_COMPOSERS = [
       // The direction is scoped to the two files by name BEFORE the Edit tool is offered, per the hazard
       // GRID_SCOPED records: the rulings tail below names the placement file precisely to forbid re-reading
       // it, and an unscoped Edit affordance beside a named path is an invitation to edit it.
-      `You are RESUMING your own synthesis session — your narrative and inputs are already in your context; do NOT redo the analysis.`,
+      `This is a fresh session: your earlier synthesis is not in your context, and you do NOT redo the analysis.`,
               `Exactly ${quarantined.length} finding object(s) in ${findings} failed the strict parse. Fix ONLY these objects and change NOTHING else:`,
               ...quarantined.map((q) => `- "${q.mark}" (index ${q.index}): ${String(q.error ?? "invalid shape").slice(0, 160)}`),
               `THE FINDINGS CONTRACT IS CLOSED — MINIMAL EDIT ONLY: change the smallest set of existing fields these errors require; NEVER invent a key, a state, or an enum value. A correction that cannot be expressed in existing fields goes in the finding's prose/impact text. ONE exception: a finding re-typed TO "off-field" also gets "off_field_ground" ("different-field" only where its goods_proximity reads "low", else "no-material-risk"), re-typing away from off-field removes it, and every finding that is not "withdrawn" carries a non-empty "legal_position" and "practical_position".`,
-              `Send the correction with \`record_synthesis\`: a PATCH call carrying \`findings_patch\` — the complete corrected finding object(s), each with the \`ordinal\` it replaces — and nothing else. The driver is holding every value you already sent and re-renders both files from them, so what you do not name comes back byte-identical. There is no file for you to write or edit and nothing you write by hand is read.`,
+              `Send the correction with \`record_synthesis\`: a PATCH call carrying \`findings_patch\` — the complete corrected finding object(s), each with the \`ordinal\` it replaces — and nothing else. The driver merges this patch into the last accepted record, keeps the values the patch does not replace, and renders both files. There is no file for you to write or edit and nothing you write by hand is read.`,
             ),
     samples: [{ name: "one quarantined finding object", tail: "tool", args: { findings: "findings.json", quarantined: [{ mark: "NOVA", index: 2, error: "band missing" }] } }],
   },
@@ -396,7 +554,7 @@ export const REPAIR_COMPOSERS = [
     stage: "synthesis",
     key: "synthesis:action-reemit",
     compose: ({ findings, bad }) => lines(
-        `You are RESUMING your own synthesis session — your narrative and inputs are already in your context; do NOT redo the analysis.`,
+        `This is a fresh session: your earlier synthesis is not in your context, and you do NOT redo the analysis.`,
         `Exactly ${bad.length} object(s) in the "actions" register of ${findings} failed the strict parse. Fix ONLY these objects and change NOTHING else — no finding changes, no new actions, none removed:`,
         // The id is what the seat can find its own row by; `kind` is echoed because a kind defect is
         // the one case where the id alone does not locate the fault in the seat's own reading.
@@ -411,7 +569,7 @@ export const REPAIR_COMPOSERS = [
     stage: "synthesis",
     key: "synthesis:ask-answer-reemit",
     compose: ({ findings, bad }) => lines(
-        `You are RESUMING your own synthesis session — your narrative and inputs are already in your context; do NOT redo the analysis.`,
+        `This is a fresh session: your earlier synthesis is not in your context, and you do NOT redo the analysis.`,
         `Exactly ${bad.length} object(s) in the "ask_answers" array of ${findings} failed the strict parse. Fix ONLY these objects and change NOTHING else — no finding changes, no action changes:`,
         ...bad.map((q) => `- ask_answers index ${q.index}${q.ask ? ` (ask "${q.ask}")` : ""}: ${String(q.error ?? "invalid shape").slice(0, 160)}`),
         `THE SHAPE IS CLOSED — MINIMAL EDIT ONLY. Each entry is EXACTLY {"ask","answer"} plus an OPTIONAL "ordinals" array of finding ordinals. \`ask\` is the requester's instruction VERBATIM (it is the join key to the frozen intake asks). \`answer\` is the ANSWER ALONE — never prefixed with "You asked: … →", which the driver adds when it builds the section. Do not resolve a defect by DELETING the entry: the ask was committed at intake and would then ship unanswered.`,
@@ -424,7 +582,7 @@ export const REPAIR_COMPOSERS = [
     stage: "register-digest",
     key: "register-digest:late-bind",
     compose: ({ registerFindings, bind }) => lines(
-        `You are RESUMING your earlier register-digest session — your prior digest and all unit files are already in your context. Do NOT redo it from scratch and do NOT run any new searches.`,
+        `This is a fresh session: your earlier register-digest work is not in your context, and the unit files are among the inputs listed below. Your prior digest is ${registerFindings}. Do NOT redo it from scratch and do NOT run any new searches.`,
         `The applicant has been named mid-run: ${bind.customer}.${bind.exclusions.length ? ` Affiliate/exclusion set: ${bind.exclusions.join(", ")}.` : ""}`,
         `Re-classify your existing findings against this: marks owned by the applicant/exclusion set are the client's OWN rights (not conflicts — move them out of the adverse tiers and note them as own-rights context); any finding previously treated as candidate-self resolves normally. Everything the re-classification does not touch stays as it is.`,
         // ── CONVERTED (conversion 11). `editRepairTail(registerFindings)` stood here and ordered
@@ -446,7 +604,7 @@ export const REPAIR_COMPOSERS = [
     stage: "common-law-half",
     key: "common-law-half:connotation-remedy",
     compose: ({ findingsFile, gridSpecPath, tok }) => lines(
-        `You are RESUMING your own common-law session — your findings file is ${findingsFile} and your prior work is in context. Do NOT redo the sweep and do NOT rewrite your findings file. You own this matter's MEANING SWEEP (your spec: ${gridSpecPath}).`,
+        `This is a fresh session: your earlier common-law work is not in your context, and your findings file is ${findingsFile}. Do NOT redo the sweep and do NOT rewrite your findings file. You own this matter's MEANING SWEEP (your spec: ${gridSpecPath}).`,
         `The MERGED findings failed the meaning-receipts gate (${abbrev(tok, 160)}). Fix exactly this: ensure ${correctionHint(tok, { gridLedgerName: gridLedgerNameFor(findingsFile) })}.`,
         `Everything else in your half stays exactly as it is — the driver re-merges the halves and re-runs the canonical gate in code.`,
         `Record the outstanding rulings ONLY by calling the \`record_dispositions\` tool with grid_spec_path = ${gridSpecPath} — never by writing or editing any file. Everything already recorded is kept; stop when the tool's answer reports nothing outstanding.`,
@@ -469,7 +627,7 @@ export const REPAIR_COMPOSERS = [
     stage: "register-unit",
     key: "register-unit:plan-join",
     compose: ({ axis, registerPlan, bandPath, entries }) => lines(
-        `You are RESUMING your own register-unit session (axis "${axis}"). Your unit digest stands — do NOT redo it.`,
+        `This is a fresh session: your earlier register-unit work (axis "${axis}") is not in your context. Your unit digest stands — do NOT redo it.`,
         `These DICTATED plan entries have no band block yet:`,
         ...entries.map((e) => `- qid "${e.qid}": ${e.predicate} ${e.terms ? `names ${JSON.stringify(e.terms)}` : `"${e.term}"`} · nice_classes ${JSON.stringify(e.nice_classes)}${e.regions?.length ? ` · regions ${JSON.stringify(e.regions)}` : ""} · expected: ${e.expected_kind}`),
         `Close them by calling register_execute_plan ONCE with {"plan_path": ${JSON.stringify(registerPlan)}, "axis": "${axis}", "output_path": ${JSON.stringify(bandPath)}, "qids": ${JSON.stringify(entries.map((e) => e.qid))}} — the tool runs ONLY those entries and MERGES the band itself (your judgment blocks and every other block stay as they are; the missing dictated blocks land, qids stamped). Do NOT run the entries manually or edit the band yourself, and do not call it without qids: that re-runs every entry on the axis.`,
@@ -484,21 +642,23 @@ export const REPAIR_COMPOSERS = [
     trigger: "xcheck-decide",
     stage: "register-unit",
     key: "register-unit:xcheck-decide",
-    compose: ({ axis, entries }) => lines(
-        `You are RESUMING your own register-unit session (axis "${axis}"). Your unit digest stands — do NOT redo it.`,
+    // A fresh session cannot infer the tool's arguments, so the caller supplies all three.
+    compose: ({ axis, registerPlan, bandPath, entries }) => lines(
+        `This is a fresh session: your earlier register-unit work (axis "${axis}") is not in your context. Your unit digest stands — do NOT redo it.`,
         `The web search's findings named these register questions after your reading. They wait for you like the families in your plan:`,
         ...entries.map((e) => `- qid "${e.qid}": ${e.predicate} "${e.term}" · nice_classes ${JSON.stringify(e.nice_classes)}${e.from ? ` · from ${e.from}` : ""}`),
+        `For \`register_execute_plan\`, use \`plan_path: ${JSON.stringify(registerPlan)}\`, \`axis: ${JSON.stringify(axis)}\`, and \`output_path: ${JSON.stringify(bandPath)}\`; pass only the qids you released.`,
         DECIDE_WAITING_FAMILIES,
         `Return ONLY: the band path + the tool's summary line.`,
       ),
-    samples: [{ name: "a cross-check the web search named", tail: "tool", args: { axis: "primary-sweep", entries: [{ qid: "xcheck-owner-lanternwick-studio", predicate: "owner", term: "Lanternwick Studio", nice_classes: ["9"], from: "https://shop.example.com/lanternwick" }] } }],
+    samples: [{ name: "a cross-check the web search named", tail: "tool", args: { axis: "primary-sweep", registerPlan: "register-plan.json", bandPath: "bands/primary-sweep.md", entries: [{ qid: "xcheck-owner-lanternwick-studio", predicate: "owner", term: "Lanternwick Studio", nice_classes: ["9"], from: "https://shop.example.com/lanternwick" }] } }],
   },
   {
     trigger: "grid-ledger",
     stage: "common-law",
     key: "common-law:grid-ledger",
     compose: ({ gridLedger, gridSpecPath }) => lines(
-        `You are RESUMING your own common-law session. Your findings file is already written and stands.`,
+        `This is a fresh session: your earlier common-law work is not in your context. Your findings file is already written and stands.`,
         `The grid ledger ${gridLedger} is missing — the deterministic grid call did not complete. Call perplexity_research again with enable_sandbox:true and grid_spec_path: ${gridSpecPath}. The tool writes the ledger itself from the API response; do NOT write it yourself and do NOT re-emit the grid JSON.`,
         `Then return ONLY: the grid ledger path + one line confirming the tool reported it written.`,
       ),
@@ -509,7 +669,7 @@ export const REPAIR_COMPOSERS = [
     stage: "common-law",
     key: "common-law:coverage-closure",
     compose: ({ findingsFile, suppSpec, suppSpecPath, closable, cellKey, sourceChannels }) => lines(
-        `You are RESUMING your own common-law session — your findings file is ${findingsFile} and your prior work is in context. Do NOT redo the full sweep.`,
+        `This is a fresh session: your earlier common-law work is not in your context, and your findings file is ${findingsFile}. Do NOT redo the full sweep.`,
         suppSpec ? `These ${closable.length} grid cells are recorded as not-executed/coverage-limited with NO mechanical failure behind them — they are closable now. Run them via the DETERMINISTIC supplementary search-as-code grid: call perplexity_research with enable_sandbox:true and grid_spec_path: ${suppSpecPath}. The tool runs EXACTLY the dictated cells and WRITES the supplementary ledger to its output_path itself — do NOT save it yourself and do NOT re-emit the grid JSON. The cells:` : "",
         ...(suppSpec ? closable.map((c) => `- ${cellKey(c)}`) : []),
         sourceChannels.length ? `IN-SCOPE CHANNELS not searched this run (the blind frame-diff flagged them as applied-but-unsearched distribution/discovery surfaces — CLOSE them, never recommend them): ${sourceChannels.join("; ")}. For EVERY manifest variant, run the appropriate search of each channel — its real domain(s) (e.g. github.com / nuget.org / npmjs.com, or the relevant store/registry) or a general-web search scoped to it — and ADD one Negative-results matrix row per (variant × channel) with its receipt, then reconcile the matching Scope-ledger / Coverage rows from not-searched to searched.` : "",
@@ -527,7 +687,7 @@ export const REPAIR_COMPOSERS = [
     stage: "common-law-half",
     key: "common-law-half:coverage-closure",
     compose: ({ findingsFile, gridSpecPath, suppSpec, suppSpecPath, cells, cellKey, chans, scopes }) => lines(
-        `You are RESUMING your own common-law session — your findings file is ${findingsFile} and your prior work is in context. Do NOT redo the full sweep. You own ONE HALF of this matter's grid (your half-grid spec: ${gridSpecPath}).`,
+        `This is a fresh session: your earlier common-law work is not in your context, and your findings file is ${findingsFile}. Do NOT redo the full sweep. You own ONE HALF of this matter's grid (your half-grid spec: ${gridSpecPath}).`,
         suppSpec ? `These ${cells.length} grid cells are recorded as not-executed/coverage-limited with NO mechanical failure behind them — they are closable now. Run them via the DETERMINISTIC supplementary search-as-code grid: call perplexity_research with enable_sandbox:true and grid_spec_path: ${suppSpecPath}. The tool runs EXACTLY the dictated cells and WRITES the supplementary ledger to its output_path itself — do NOT save it yourself and do NOT re-emit the grid JSON. The cells:` : "",
         ...(suppSpec ? cells.map((c) => `- ${cellKey(c)}`) : []),
         chans.length ? `IN-SCOPE CHANNELS not searched this run (the blind frame-diff flagged them as applied-but-unsearched distribution/discovery surfaces — CLOSE them, never recommend them): ${chans.join("; ")}. For EACH of these variants — ${scopes.join("; ")} — (the driver dictates this list; it may include the sibling half's terms re-routed to you because its session is unavailable), run the appropriate search of each channel — its real domain(s) (e.g. github.com / nuget.org / npmjs.com, or the relevant store/registry) or a general-web search scoped to it — and ADD one Negative-results matrix row per (variant × channel) with its receipt, then reconcile the matching Scope-ledger / Coverage rows from not-searched to searched.` : "",
@@ -541,7 +701,7 @@ export const REPAIR_COMPOSERS = [
     stage: "common-law",
     key: "common-law:frame-reopen",
     compose: ({ findingsFile, gridLedger, directives }) => lines(
-        `You are RESUMING your own common-law session — your findings file is ${findingsFile} and your prior work is in context. Do NOT redo the full sweep.`,
+        `This is a fresh session: your earlier common-law work is not in your context, and your findings file is ${findingsFile}. Do NOT redo the full sweep.`,
         `A blind, frame-INDEPENDENT re-derivation found these SOURCE CHANNELS the run did NOT search. Run a supplementary search over them (enable_sandbox: true, depth: "pro-search") — resolve each channel to its real domain(s) or a general-web search scoped to it:`,
         ...directives.map((d) => `- ${d.item} — ${d.observation}`),
         `Then update the Negative-results matrix + Coverage ledger for what you searched, preserving everything else. Do NOT hand-edit ${gridLedger} — the driver owns the machine ledger. The edit direction below covers ${findingsFile} ONLY.`,
@@ -554,7 +714,7 @@ export const REPAIR_COMPOSERS = [
     stage: "common-law-half",
     key: "common-law-half:frame-reopen",
     compose: ({ findingsFile, gridSpecPath, gridLedger, directives, scopes }) => lines(
-        `You are RESUMING your own common-law session — your findings file is ${findingsFile} and your prior work is in context. Do NOT redo the full sweep. You own ONE HALF of this matter's grid (your half-grid spec: ${gridSpecPath}).`,
+        `This is a fresh session: your earlier common-law work is not in your context, and your findings file is ${findingsFile}. Do NOT redo the full sweep. You own ONE HALF of this matter's grid (your half-grid spec: ${gridSpecPath}).`,
         `A blind, frame-INDEPENDENT re-derivation found these SOURCE CHANNELS the run did NOT search. For EACH of these variants — ${scopes.join("; ")} — (the driver dictates this list; it may include the sibling half's terms re-routed to you because its session is unavailable), run a supplementary search over them (enable_sandbox: true, depth: "pro-search") — resolve each channel to its real domain(s) or a general-web search scoped to it:`,
         ...directives.map((d) => `- ${d.item} — ${d.observation}`),
         `Then update the Negative-results matrix + Coverage ledger for what you searched, preserving everything else. Do NOT hand-edit ${gridLedger} — the driver owns the machine ledger. The edit direction below covers ${findingsFile} ONLY.`,
@@ -702,7 +862,7 @@ export const REPAIR_COMPOSERS = [
     // Its key differs from the spec'd arm because both dispatch under `trigger: "grid-ledger"` on the
     // same stage — a trigger-only key would have resolved both to whichever came first.
     compose: ({ gridLedger }) => lines(
-      `You are RESUMING your own common-law session. Your findings file is already written and stands.`,
+      `This is a fresh session: your earlier common-law work is not in your context. Your findings file is already written and stands.`,
       `One artifact is missing: save the grid call's stdout JSON VERBATIM to ${gridLedger} — the single stdout object, or a JSON ARRAY of the per-batch stdout objects in batch order. Copy it exactly as the tool returned it; do not reformat, re-type, or judge.`,
       `Then return ONLY: that absolute path + one line confirming the save.`,
     ),