clearotron 0.5.0-beta.3 → 0.5.0-beta.4

package/driver/pipeline.mjs

@@ -34,7 +34,7 @@ import { paths, STAGES, axisTier, decideAxes, assertTierSanity, assertEffectiveT
   chainEntries, stageOrdinal, stageInputs, stageOutputs, dependencyOrder, REGISTER_AXES, REGISTER_ENUMERATE_TOOL,
   buildEscalationFollowup, buildEnvelopeCloseFollowup, buildFrameReopenFollowup,
   buildFrameReopenRetryMessage, thinkingFor, composeFollowup, stampDispatchBlocks, recordEmptyReturn, nothingFound, nothingToRead, PROVIDER_META, proseRungDirective, inquiryRungDirective } from "./stages.mjs"; import { bandSizeForStage, derivedLimitSec, limitExceedsCeiling, ceilingRefusal, stagesRefusingBand } from "./band-size.mjs";
-import { handResearchAnswers } from "./research-answers.mjs";   // the research a stage's earlier attempts got, handed to a later one
+import { handResearchAnswers, RESEARCH_REPLAY_FILE, savedResearchCount } from "./research-answers.mjs";   // the research a stage's earlier attempts got, handed to a later one; a replay of it
 import { IDENTITY_FILE as REPORT_IDENTITY_FILE, renderReportOverview } from "./report-overview-record.mjs";
 import { writePartNotCompleted, readPartNotCompleted, clearPartNotCompleted, clearPartsNotCompleted, NOT_COMPLETED_DIR, slicesNotYetRecorded, axesNotYetDisclosed, unitsNotYetRecorded } from "./parts-not-completed.mjs";
 import { renderUnitNote, readBandAccount } from "./register-unit-record.mjs";   // a unit that could not finish, its note rendered from its band
@@ -153,7 +153,7 @@ import { escalatedAxes } from "./skeptic-record.mjs";   // THE escalation parse
 // — every placed candidate ends somewhere a reader can see; the ones that do not are counted by name
 import { PLACEMENT_CARRY_SCHEMA_VERSION, reconcilePlacementCarry, placementCarryEvent, mintPlacementCarryDoubts, entryUris, parseCarrySurfaces, classifyPlacement } from "./placement-carry.mjs";
 import { FLOOR_DUTY_SCHEMA_VERSION, reconcileFloorDuty, floorDutyEvent, armFloorDuty, floorDutyArmed, floorDutyBlock, floorDutyClosed, floorDutyBlocksSkip } from "./floor-duty.mjs";   // — the era stamp that turns disclosure into a delivery floor
-import { synthesisDutyForRun, snapshotSynthesisBase, restoreSynthesisBase, rebaseSynthesis, lastAcceptedCall, acceptSynthesis, driverReadsFor } from "./synthesis-record.mjs";   // — the duty checked against the DELIVERED document; the merge base a corrective pass holds and puts back
+import { synthesisDutyForRun, snapshotSynthesisBase, restoreSynthesisBase, rebaseSynthesis, lastAcceptedCall, acceptSynthesis, driverReadsFor, handSavedFindings } from "./synthesis-record.mjs";   // — the duty checked against the DELIVERED document; the merge base a corrective pass holds and puts back
 import { RECORD_CARRY_SCHEMA_VERSION, traceRecordCarry, parseStageOutcomes, recordCarryEvent, mintRecordCarryDoubts, recordCarryDoubtsAgain, bandRecordUri, placementIndex, findingUris , silentlyLostFindings, statedDivergenceFindings } from "./record-carry.mjs"; import { pickingExits, notesExits, notesPageRows, exitsForLog } from "./hand-off-exits.mjs";
 import { reconcileSurfaceDuty, surfaceDutyNote } from "./surface-duty.mjs";   // item 3 — silence at the findings surface, read off the rows above
 import { DISCARD_LEDGER_NAME, seamRows, appendDiscardRows, foldDiscardLedger } from "./record-discard.mjs";
@@ -1679,6 +1679,8 @@ const AXIS_VOCABULARY = {
 // a preserved run's canonical artefact came from); the rest are the re-dispatch triggers runDigest
 // labels, and they carry the placement rulings tail a fresh pass does not.
 export const DISPATCH_TRIGGERS = ["fresh", "escalation", "envelope", "late-bind", "stale-repair", "settlement-flush", "corrective"];   // @internal — — the corrective pass is the seam the losses happen in; see driver/corrective-arm.mjs for warm vs cold
+// How an --experiment arm's research is answered: sent out as the run sent it, or replayed from the run's own answers.
+export const RESEARCH_MODES = ["live", "replay"];   // @internal
 
 /**
  * The sha of a sandbox file AS IT WOULD READ on the canonical run — the sandbox's own directory
@@ -5007,10 +5009,15 @@ export function messageCtxFor(name, ctx) {   // @internal — driven by its test
   if (name === "narrative-refutation") return { ...ctx, placementFloorDecisions: reviewFloorDecisionLines(ctx.paths) };
   // The reading step and the writer are told placement's accepted set-asides the same way, read when the message is built.
   if (name === "register-digest") return { ...ctx, placementSetAsides: placementSetAsideLines(ctx.paths) };
-  // The writer is also handed the research its earlier attempts got (research-answers.mjs), written to the run folder when
-  // the message is built: none on a first attempt, so its message is unchanged.
+  // The writer is also handed the research this run's earlier stages and attempts got (research-answers.mjs), written to
+  // the run folder when the message is built: none on a run that has asked nothing yet, whose message is unchanged.
+  // A sandbox arm reproducing a FIRST attempt hands on nothing: its copy holds the run's own answers under this stage's
+  // key, which a first attempt in a run never has (`researchHandOff`, set by the experiment).
   if (name === "synthesis") return { ...ctx, placementSetAsides: placementSetAsideLines(ctx.paths),
-    researchAnswered: ctx.run ? handResearchAnswers(ctx.paths.runDir, stageSessionKey(ctx, name)) : 0 };
+    researchAnswered: ctx.run && ctx.researchHandOff !== false ? handResearchAnswers(ctx.paths.runDir, stageSessionKey(ctx, name), { ofRun: true }) : 0,
+    // The findings an earlier attempt saved, handed on as a file (synthesis-record.mjs): none on a first attempt, and none
+    // in a sandbox arm, whose copy holds no saved findings.
+    savedSynthesis: handSavedFindings(ctx.paths.runDir) };
   return ctx;
 }
 
@@ -18438,6 +18445,12 @@ async function runExperimentInner(job, opts) {
     throw new Error(`--experiment ${name}: --axis "${axis}" is not ${vocab.what} (${vocab.oneOf})`);
   // A typo here changes WHICH driver-computed blocks the arm carries and nothing would say so — the
   // same silent-degradation shape the RETIRED_FLAGS table at the bottom of this file exists for.
+  // `--research replay` answers the arm's research from the run's own answers and sends nothing out
+  // (research-answers.mjs). Only a stage that holds the research tool has research to replay.
+  if (opts.research != null && !RESEARCH_MODES.includes(opts.research))
+    throw new Error(`--research: unknown value "${opts.research}" — one of: ${RESEARCH_MODES.join(", ")}`);
+  if (opts.research === "replay" && !experimentToolGroups(name).includes("perplexity"))
+    throw new Error(`--experiment ${name} --research replay: ${name} holds no research tool, so there is no research to replay`);
   if (opts.dispatchTrigger != null && !DISPATCH_TRIGGERS.includes(opts.dispatchTrigger))
     throw new Error(`--dispatch-trigger: unknown value "${opts.dispatchTrigger}" — it decides which production pass the arm reproduces, so a typo would compose a quietly different prompt. One of: ${DISPATCH_TRIGGERS.join(", ")}`);
   const ctx = reconstructCtx(job, opts);
@@ -18451,7 +18464,10 @@ async function runExperimentInner(job, opts) {
   // Any ctx field holding a PATH is dropped rather than inherited: reconstructCtx resolved them against
   // the canonical run, and a sandbox whose prompt names a canonical path is not a sandbox. The
   // derivations below re-set them against ctx.paths, which here is the shadow dir.
-  const shadowCtx = { ...ctx, paths: paths(shadowDir), axis, gridSpecPath: null, clHalfTerms: null };
+  // A `fresh` arm is a stage's first attempt, which is handed no earlier attempt's research: the copied answers are
+  // what the replay answers from, never a hand-off production's first attempt does not get.
+  const shadowCtx = { ...ctx, paths: paths(shadowDir), axis, gridSpecPath: null, clHalfTerms: null,
+    researchHandOff: (opts.dispatchTrigger ?? "fresh") !== "fresh" };
   const inputOpts = { axes: ctx.axes, axis, registerOnly: ctx.registerOnly };
   const manifest = sandboxManifest(name, ctx.paths, inputOpts);
   // ── 1. GATHER — the sandbox manifest, not the freshness list ──────────────────────────────────────
@@ -18502,6 +18518,15 @@ async function runExperimentInner(job, opts) {
     throw new Error(`--experiment ${name}: the sandbox could not reproduce ${gaps.length} thing(s) this stage's context has on the canonical run — refusing to dispatch against an incomplete context:\n` +
       gaps.map((g) => `  · ${g.rel}  [${g.kind}${g.via ? ` via ${g.via}` : ""}]${g.why ? ` — ${g.why}` : ""}`).join("\n"));
   }
+  // A REPLAY NEEDS ANSWERS TO REPLAY. Refused by name when the run kept none, rather than dispatched to refuse
+  // every question it asks; the marker is the research server's whole switch, and only a sandbox writes it.
+  let replayedAnswers = null;
+  if (opts.research === "replay") {
+    replayedAnswers = savedResearchCount(shadowDir);
+    if (!replayedAnswers)
+      throw new Error(`--experiment ${name} --research replay: this run kept no research answers (_driver/research-answers.jsonl is absent or holds none), so there is nothing to replay — run the arm with --research live`);
+    atomicWrite(driverDir(shadowDir, RESEARCH_REPLAY_FILE), JSON.stringify({ replayOf: "the run's saved research answers", answers: replayedAnswers }, null, 2) + "\n");
+  }
   // ── 4. INLINE context — what no file copy can supply ──────────────────────────────────────────────
   //
   // `report-card` receives its finding as ctx.finding; its declared findings.json exists for staleness,
@@ -18588,6 +18613,10 @@ async function runExperimentInner(job, opts) {
     // omitted: absent and "there was none" are different facts and only one of them is a defect.
     ratedUnder: ctx.profile?.profileKey ?? null,
     dispatchTrigger: opts.dispatchTrigger ?? "fresh",
+    // How the arm's research was answered: sent out live, or replayed from the run's own answers.
+    research: opts.research === "replay" ? { mode: "replay", answers: replayedAnswers } : { mode: "live" },
+    // Whether the arm's message hands on an earlier attempt's research, as a retry's does: never on a `fresh` arm.
+    researchHandOff: shadowCtx.researchHandOff,
     // — WHICH PASS THIS ARM REPRODUCED, in a word. null on a non-corrective arm;
     // never "dispatched-warm", which is production's alone.
     correctivePass: whichPass,
@@ -18693,7 +18722,7 @@ function parseArgv(argv) {
   const o = {};
   const flags = { "--job": "job", "--agent": "agent", "--resume": "codename", "--from": "fromStage",
     "--experiment": "experiment", "--model": "model", "--instructions": "instructions",
-    "--label": "label", "--axis": "axis", "--dispatch-trigger": "dispatchTrigger" };
+    "--label": "label", "--axis": "axis", "--dispatch-trigger": "dispatchTrigger", "--research": "research" };
   for (let i = 0; i < argv.length; i++) {
     const key = flags[argv[i]];
     if (!key) {
@@ -18861,7 +18890,7 @@ export function resumeAdvice({ result = null, error = null, signal = null, scrip
 
 const USAGE = "usage: node pipeline.mjs --job <file.json> [--agent <id>]\n" +
   "       [--resume <codename> [--from <stage>]]\n" +
-  "       [--resume <codename> --experiment <stage> [--model <id>] [--instructions <text>] [--axis <axis>] [--label <text>] [--dispatch-trigger <t>]]\n" +
+  "       [--resume <codename> --experiment <stage> [--model <id>] [--instructions <text>] [--axis <axis>] [--label <text>] [--dispatch-trigger <t>] [--research live|replay]]\n" +
   "  --instructions appends to a stage's prompt (a light tweak); a full prompt rewrite means editing the stage's skill file.\n" +
   "  --axis also names the ORDINAL for report-card (its dispatch label is report-card:<ordinal>).\n" +
   "  --dispatch-trigger picks WHICH production pass the arm reproduces (default \"fresh\"); a corrective pass carries prompt blocks a fresh one does not.";
@@ -18976,7 +19005,7 @@ if (isEntrypoint(import.meta.url)) void (async () => {
   // hangs `__runRef` on the caller's own opts the moment the run context is built, which is how pipeline()'s
   // rate-limit catch already finds the run to postpone; the same hook lets a THROWN exit name the run.
   const opts = a.experiment
-    ? { ...base, codename: a.codename, experiment: a.experiment, model: a.model, instructions: a.instructions, axis: a.axis, label: a.label, dispatchTrigger: a.dispatchTrigger }
+    ? { ...base, codename: a.codename, experiment: a.experiment, model: a.model, instructions: a.instructions, axis: a.axis, label: a.label, dispatchTrigger: a.dispatchTrigger, research: a.research }
     : { ...base, codename: a.codename, fromStage: a.fromStage, ...(a.job ? {} : { jobRebuiltFromStatus: true }) };
   const script = resolve(fileURLToPath(import.meta.url));
   // `jobPath` is null on a rebuilt resume, so the advice composes a command that does not name a file

package/driver/placement-decisions.mjs

@@ -15,7 +15,7 @@ import { dirname } from "node:path";
 import { createHash } from "node:crypto";
 import { buildSelectionIndex, setAsideGrounds, isSetAsideGroupRow, lineKey, groupName, servedLines, FLOOR_GROUND_ON } from "./placement-form.mjs";
 import { unionPlacementForm } from "./placement-union.mjs";
-import { readPlacementForm, readPlacementFormInput } from "./placement-form-io.mjs";
+import { readPlacementForm, readPlacementFormInput, placementFormStamp, placementFormPaths } from "./placement-form-io.mjs";
 import { parsePlacementsJson } from "./placement-model.mjs";
 
 const safeReadJson = (p) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; } };
@@ -118,9 +118,20 @@ export function placementFloorDecisionLines(P) {   // @internal — driven by it
  * enough for a stage to open. [] when nothing stands or nothing can be read. IMPURE (reads the run).
  */
 export function standingPlacementDecisions(P) {   // @internal — driven by its test with a run's own files
+  // A FORM THAT IS NOT THERE IS NOT "NOTHING SET ASIDE". Every failure here used to read as an empty list, so a writer in
+  // the experiment sandbox, which held no form, was told of no set-aside at all on a run whose placement had set 178
+  // aside. Where this run's placement records its decisions on a form (the era stamp), a missing or unreadable form is
+  // refused by name, and so is a failure reading what stands. A run from before the form had none, and its empty list
+  // is true.
+  const form = readPlacementForm(P.runDir);
+  if (form.error) throw new Error(`placement_form_unreadable: ${form.error} — placement's set-asides cannot be read, and an unread form is not "none set aside"`);
+  if (!form.present) {
+    if (placementFormStamp(P.runDir).required)
+      throw new Error(`placement_form_missing: this run's placement records its decisions on a form, and ${placementFormPaths(P.runDir).sidecar} is not there — refusing to read its absence as "none set aside"`);
+    return [];
+  }
+  if (!form.set_aside?.length) return [];
   try {
-    const form = readPlacementForm(P.runDir);
-    if (!form.set_aside?.length) return [];
     const input = readPlacementFormInput(P.runDir);
     const index = buildSelectionIndex(input);
     return standingSetAside(form.set_aside, input, { placedUris: placedUriRows(P).map((r) => r.uri), rows: form.rows }).flatMap((e) => {
@@ -132,7 +143,7 @@ export function standingPlacementDecisions(P) {   // @internal — driven by its
       return [{ kind: "name", record: e.set_aside, mark: c?.mark ?? null, owner: c?.owner ?? null, ground: e.ground,
         ...(FLOOR_GROUND_ON.includes(e.on) ? { on: e.on } : {}) }];
     });
-  } catch { return []; }
+  } catch (e) { throw new Error(`placement_decisions_unreadable: ${String(e?.message ?? e).slice(0, 200)} — what placement set aside could not be worked out from its form`); }
 }
 
 /**
@@ -144,7 +155,11 @@ export function rankingNow(P) {   // @internal — driven by its test with a run
   const records = new Map();
   for (const r of placedUriRows(P)) records.set(String(r.uri).toLowerCase(), `placed:${r.tier ?? ""}`);
   const groups = new Map();
-  for (const d of standingPlacementDecisions(P)) {
+  // The re-rank count runs inside the delivery loop, and a run always delivers: here a refusal counts no decision, and
+  // the writer's own message, which reads the same decisions, is where it is refused.
+  let decisions = [];
+  try { decisions = standingPlacementDecisions(P); } catch { decisions = []; }
+  for (const d of decisions) {
     if (d.kind === "group") groups.set(d.group, { key: `${d.ground}|${d.covers_lines}|${d.covered_lines_hash}`, records: d.records });
     else records.set(String(d.record).toLowerCase(), `set aside${d.on ? ` on its ${d.on}` : ""}: ${d.ground}`);
   }

package/driver/predelivery-lint.mjs

@@ -1256,11 +1256,18 @@ export function correctionConsistencyChecks({ reportMd, clientSummaryMd, auditMd
   const report = String(reportMd ?? "");
   const cs = String(clientSummaryMd ?? "");
   const audit = String(auditMd ?? "");
+  // A CARD THAT CARRIES ITS OWN `- ord:` LINE IS THE FINDING THAT LINE NAMES. One owner can hold the same mark in
+  // several records, each its own finding, and a live one keeps its card under the same head when another is
+  // withdrawn: read by its head, it was the withdrawn finding back, and that one false failure closed the client
+  // export of a crowded test run (2026-10-28). The ord line already answers for such a card, so the head match is
+  // for a card with none, the older card shape.
+  const unnumberedHeads = [...report.matchAll(/^##\s+([^\n]+)\n?((?:- [^\n]*\n?)*)/gm)]
+    .filter(([, , meta]) => !/^-\s*ord:/m.test(meta)).map(([, h]) => h);
   for (const f of withdrawn) {
     const ord = f.ordinal;
     const markN = norm(f.mark), ownerN = norm(f.owner?.name);
     const ordHit = ord != null && new RegExp(`^-\\s*ord:\\s*${ord}\\s*$`, "m").test(report);
-    const headHit = [...report.matchAll(/^##\s+([^\n]+)$/gm)].some(([, h]) => {
+    const headHit = unnumberedHeads.some((h) => {
       const hN = norm(h);
       return markN && ownerN && hN.includes(markN) && hN.includes(ownerN);
     });

package/driver/register-digest-record.mjs

@@ -146,13 +146,16 @@ export function accountedUris(model, owed = []) {
  * THE SHEET-2 ROWS THE DRIVER WRITES. A sheet-2 entry is adopted as placement placed it: one row, on the entry's first
  * live record (else its first), carrying placement's reason word for word, with verify "yes" because nothing has checked
  * it against the live register. An entry the write-up overrode gets none: any row of its own naming any of the entry's
- * records, or a disagreement resolution naming one, is its ending instead. An entry whose record the band does not
- * hold gets none. PURE.
+ * records, or an OVERRODE resolution naming one, is its ending instead. An ADOPTED resolution keeps placement's
+ * placement, so the entry keeps its row: counting it as an ending rendered an adoption exactly as an override, and
+ * kept entries vanished from the table the writer is owed from. An entry whose record the band does not hold gets
+ * none. PURE.
  */
 export function adoptedRows(model, facts = emptyFacts()) {
   const adopt = Array.isArray(facts?.adopt) ? facts.adopt : [];
   if (!adopt.length) return [];
-  const named = accountedUris(model, adopt.flatMap((e) => e.uris));
+  const overrides = { ...model, disagreement_resolutions: (model?.disagreement_resolutions ?? []).filter((d) => d?.decision !== "ADOPTED") };
+  const named = accountedUris(overrides, adopt.flatMap((e) => e.uris));
   const out = [];
   for (const e of adopt) {
     if (e.uris.some((u) => named.has(u))) continue;

package/driver/research-answers.mjs

@@ -25,7 +25,7 @@
 // A first attempt has none, and its message is unchanged.
 //
 // A pure leaf: node:fs, node:path and shared/driver-dir.mjs only, so the research server can import it.
-import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { driverDir } from "../shared/driver-dir.mjs";
 
@@ -51,9 +51,13 @@ export function keepResearchAnswer(runDir, { session = null, agent = null, task,
 /**
  * The research answers the session `sessionKey` and its retries got, oldest first, one per question: the latest answer
  * to each exact question. [] when there are none, or no record. A torn line is skipped. IMPURE (reads the record).
+ *
+ * `ofRun` widens it to every stage of this run: the writer is told to use an answer this run already holds, from an
+ * earlier stage as from an earlier attempt, and it cannot open `_driver/` itself. The record is the run's own file, so
+ * nothing another run asked can be in it.
  * @returns {{ task: string, text: string, ts: string }[]}
  */
-export function researchAnswersFor(runDir, sessionKey) {
+export function researchAnswersFor(runDir, sessionKey, { ofRun = false } = {}) {
   if (!runDir || !sessionKey) return [];
   let raw = "";
   try { raw = readFileSync(driverDir(runDir, RESEARCH_ANSWERS_FILE), "utf8"); } catch { return []; }
@@ -63,7 +67,7 @@ export function researchAnswersFor(runDir, sessionKey) {
     if (!line.trim()) continue;
     let row;
     try { row = JSON.parse(line); } catch { continue; }
-    if (!own(row?.session) || typeof row.task !== "string" || !row.task.trim() || !isResearchAnswer(row.text)) continue;
+    if ((!ofRun && !own(row?.session)) || typeof row.task !== "string" || !row.task.trim() || !isResearchAnswer(row.text)) continue;
     byTask.delete(row.task);   // the latest answer to a question takes the place of an earlier one
     byTask.set(row.task, { task: row.task, text: row.text, ts: String(row.ts ?? "") });
   }
@@ -83,8 +87,8 @@ export const researchAnswerLine = (n, { task, text }) => `Question ${n}: ${oneLi
  * folder, one question and its answer per line, and return how many. Nothing is written when there are none, and 0 is
  * returned when the file could not be written: a message must never name a file that is not there. IMPURE.
  */
-export function handResearchAnswers(runDir, sessionKey) {
-  const answers = researchAnswersFor(runDir, sessionKey);
+export function handResearchAnswers(runDir, sessionKey, opts = {}) {
+  const answers = researchAnswersFor(runDir, sessionKey, opts);
   if (!answers.length) return 0;
   try {
     const p = join(runDir, RESEARCH_ANSWERS_MD);
@@ -101,8 +105,51 @@ export function handResearchAnswers(runDir, sessionKey) {
 export function researchAnsweredBlock(n) {
   if (!(n > 0)) return "";
   const asked = n === 1 ? "asked 1 question and got its answer" : `asked ${n} questions and got their answers`;
-  return `RESEARCH THIS RUN HAS ALREADY ANSWERED: an earlier attempt of this stage ${asked}. They are in ${RESEARCH_ANSWERS_MD}, `
+  return `RESEARCH THIS RUN HAS ALREADY ANSWERED: earlier stages or attempts of this run ${asked}. They are in ${RESEARCH_ANSWERS_MD}, `
     + "one question and its answer per line. Before you ask about a finding's owner and mark, search that file for the owner's name "
-    + "with search_run_artifacts. Where one of them asked about that owner and mark for the same field and country, use its answer as "
+    + "with search_run_artifacts. Where one of them answers the same owner, mark, goods, territory and material time question, use its answer as "
     + "that finding's check, cite its URL and record it as you would a fresh one; ask only what none of them covers.";
 }
+
+// ── A REPLAY ANSWERS FROM THE RUN'S OWN RESEARCH, AND ASKS NOTHING NEW ────────────────────────────────────────────────
+//
+// A stage replayed offline in the experiment sandbox would send its research questions out again: a cost, and an
+// answer that is not the one the run got. With `--research replay` the sandbox holds the run's own answers and says so
+// in this marker, and the research server answers a question the run already asked from what the run got, and refuses
+// a question it did not ask, sending nothing out. Only the sandbox writes the marker; a run never does.
+export const RESEARCH_REPLAY_FILE = "research-replay.json";
+
+/** True when this run folder is a replay of a run's research. IMPURE (reads the marker). */
+export const researchReplayOn = (runDir) => Boolean(runDir) && existsSync(driverDir(runDir, RESEARCH_REPLAY_FILE));
+
+/**
+ * The run's latest answer to exactly this question, whichever of its stages asked it, or null. The question is
+ * matched as written, trimmed at its ends: a question worded differently is a new question. IMPURE (reads the record).
+ */
+export function savedResearchAnswer(runDir, task) {
+  const want = typeof task === "string" ? task.trim() : "";
+  if (!runDir || !want) return null;
+  let raw = "";
+  try { raw = readFileSync(driverDir(runDir, RESEARCH_ANSWERS_FILE), "utf8"); } catch { return null; }
+  let found = null;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    if (typeof row?.task !== "string" || row.task.trim() !== want || !isResearchAnswer(row.text)) continue;
+    if (!found || String(row.ts ?? "") >= String(found.ts ?? "")) found = { task: row.task, text: row.text, ts: String(row.ts ?? ""), session: row.session ?? null };
+  }
+  return found;
+}
+
+/** How many questions the run's record answers: the experiment refuses a replay with nothing to replay. IMPURE. */
+export function savedResearchCount(runDir) {
+  let raw = "";
+  try { raw = readFileSync(driverDir(runDir, RESEARCH_ANSWERS_FILE), "utf8"); } catch { return 0; }
+  const tasks = new Set();
+  for (const line of raw.split("\n")) {
+    try { const row = JSON.parse(line); if (typeof row?.task === "string" && row.task.trim() && isResearchAnswer(row.text)) tasks.add(row.task.trim()); }
+    catch { /* a torn line answers nothing */ }
+  }
+  return tasks.size;
+}

package/driver/saved-findings-block.mjs

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026 Cordillera Sàrl. Additional terms under section 7 of the AGPL-3.0 apply — see ADDITIONAL-TERMS.md
+//
+// saved-findings-block.mjs — what a later attempt of the writer is told about the findings this run already saved.
+//
+// The writer saves each finding as it completes it (synthesis-record.mjs, `saveFindings`), and an attempt that is
+// stopped keeps them. A later attempt is handed them as a file, never in its message: a saved finding carries its
+// evidence, and a few hundred of them would swamp the message. The message says how many there are, where they are,
+// that they stand, and which positions are still to settle. A first attempt has none, and its message is unchanged.
+// The model reads this block, so its words change only as model-facing wording does.
+//
+// A pure leaf, so the stage table can import it.
+
+/** The file in the run folder a later attempt is handed its run's saved findings in. */
+export const SAVED_FINDINGS_FILE = "synthesis-saved.json";
+
+/**
+ * The block a later attempt's message ends with, or "" when nothing is saved. `h` is what
+ * synthesis-record.mjs's `handSavedFindings` returned: `{ findings, declined, outstanding }`, where `outstanding` is
+ * null when the run cannot say which positions are still owed. PURE.
+ */
+export function savedFindingsBlock(h) {
+  if (!h || !(h.findings > 0)) return "";
+  const saved = h.findings === 1 ? "saved 1 finding" : `saved ${h.findings} findings`;
+  const declined = h.declined > 0 ? ` and declined ${h.declined === 1 ? "1 record" : `${h.declined} records`} through record_declination` : "";
+  const shown = Array.isArray(h.outstanding) ? h.outstanding.slice(0, 40) : [];
+  const more = Array.isArray(h.outstanding) && h.outstanding.length > shown.length ? `, and ${h.outstanding.length - shown.length} more` : "";
+  const owed = !Array.isArray(h.outstanding) ? ""
+    : h.outstanding.length ? ` Still to settle: ${h.outstanding.length === 1 ? "1 position" : `${h.outstanding.length} positions`}: ${shown.join(", ")}${more}.`
+      : " Every position you were handed is already settled by a saved finding or a declination.";
+  return `SAVED IN THIS RUN: an earlier attempt of this stage ${saved} through record_synthesis${declined}. The saved findings are in ${SAVED_FINDINGS_FILE}, `
+    + "each as it was accepted, with its evidence. They stand: save one again only for identified contrary evidence, a reasoning error "
+    + `or an applicable change in the instructions.${owed} Save each remaining finding as you complete it. Then send the whole record, `
+    + "`narrative` with `findings`: it takes every saved finding for a position its `findings[]` does not carry, so that list need hold "
+    + "only the findings not saved yet, and the overall conclusions answer for the complete set.";
+}

package/driver/skills/clearance-search/phase2-execution.md

@@ -218,7 +218,9 @@ Every cross-check (including "checked, found nothing") logged in the unified aud
 
 ## Step 3.5 — Actual-use and enforcement check (mandatory for register hits rated medium risk or higher)
 
-Before synthesis, for **every register finding** advisory-rated on a rung **the framework rates medium risk or higher** (the stage message names those rungs; a rung below that is not checked, on any client's ladder), run a marketplace check via `perplexity_research` to determine whether the registered mark is **actually being used in the marketplace within the scope of the current search** (i.e. for the goods/services and field this clearance targets). **The same query also asks for the owner's enforcement record:** whether the owner has opposed, disputed or sued over this mark or a similar one.
+For **every register finding** advisory-rated on a rung **the framework rates medium risk or higher** (the stage message names those rungs; a rung below that is not checked, on any client's ladder), run a marketplace check via `perplexity_research` to determine whether the registered mark is **actually being used in the marketplace within the scope of the current search** (i.e. for the goods/services and field this clearance targets). **The same query also asks for the owner's enforcement record:** whether the owner has opposed, disputed or sued over this mark or a similar one.
+
+Apply the existing triggers for actual-use, enforcement, and owner checks after the relevant legal assessment. First use a suitable answer already held by this run, including an earlier stage or attempt, where it answers the same owner, mark, goods, territory, and material time question. A source requirement is not a requirement for a new call. One answer may support several findings only where it answers each finding's question. Ask only what remains unanswered and record the result against every finding it supports.
 
 Example: a JELLY register hit owned by Jellycat (a toy company) for Class 9 video game software — check whether Jellycat actually sells or markets video games under JELLY. If they don't (their commercial use is toys), note the filed-vs-used distinction in Key Factors and weigh it as a Stage-2 factor together with revocation-vulnerability — no automatic downgrade (see `synthesis-rules.md` → *Actual-use assessment results*).
 
@@ -245,7 +247,7 @@ If the marketplace query genuinely returned nothing, write the honest value verb
 
 The driver's `narrative` validator (`verify.mjs` → `findUseCheckViolations`) **rejects the whole narrative** if a
 Composite 3+ use-negative finding lacks this line, so the synthesis stage cannot ship an *inferred* "no use" —
-it must actually run the scoped query (owner + mark + goods/field) and cite the result, or state the honest
+it must actually run the scoped query (owner + mark + goods/field), unless an answer this run already holds answers that question, and cite the result, or state the honest
 "no result". Never dress an un-run check as a clean negative. Also mirror the result into the matching `# Actions`
 item: "confirm the owner's actual use" becomes the stated result, not a task handed onward (this is what fills
 spec 09's "Checks we ran — what we found" bucket). On a perplexity outage the "no result" value is the accepted

package/driver/stage-context.mjs

@@ -177,6 +177,7 @@ export const TOOL_GROUP_EDGES = {
   // the policy asks on the question's own depth instead, so the arm would measure a different tier.
   perplexity: (P) => [
     { path: driverDir(P.runDir, "search-policy.json"), why: "perplexity_research sends every question on the tier the run's frozen policy pins (web.questionPreset); without it a question goes out on its own depth" },
+    { path: driverDir(P.runDir, "research-answers.jsonl"), why: "under --research replay, perplexity_research answers a question the run already asked from the answer the run kept here (research-answers.mjs); without it a replay has nothing to answer from" },
   ],
   declination: (P) => [
     { path: driverDir(P.runDir, "declination-spec.json"), why: "record_declination resolves every row_index against this spec; without it the tool refuses the call and the seat cannot decline at all" },
@@ -191,6 +192,21 @@ export const TOOL_GROUP_EDGES = {
 };
 
 // ── the edges a declaration cannot carry ─────────────────────────────────────────────────────────────
+// PLACEMENT'S SET-ASIDES, as the reading step and the writer are told them when their message is built
+// (placement-decisions.mjs, `standingPlacementDecisions`): the form's driver copy, judged against the shape, the
+// positions, the scope, what the band tools served and the goods evidence, under the era stamp that says a form is
+// required. An arm without them was told of no set-aside at all.
+const placementSetAsideReads = (P) => [
+  { path: driverDir(P.runDir, "placement-form.form.json"), kind: "driver-side", why: "standingPlacementDecisions reads placement's set-asides from the form's driver copy" },
+  { path: driverDir(P.runDir, "stage-contracts.json"), kind: "driver-side", why: "the era stamp that says this run's placement records a form; without it a missing form reads as none set aside" },
+  { path: P.placementModel, kind: "driver-side", why: "the placed records a set-aside is checked against (placedUriRows)" },
+  { path: P.bandShape, kind: "driver-side", why: "readPlacementFormInput: the floors and groups a set-aside is judged against" },
+  { path: P.registerPositions, kind: "driver-side", why: "readPlacementFormInput: the positions a named set-aside resolves to" },
+  { path: driverDir(P.runDir, "instructed-scope.json"), kind: "driver-side", why: "readPlacementFormInput: the applied-for marks a ground is refused on" },
+  { path: driverDir(P.runDir, "reading-log.jsonl"), kind: "driver-side", why: "readServed: the lines a group row may cover are the lines placement was shown" },
+  { path: driverDir(P.runDir, "goods-evidence.json"), kind: "driver-side", why: "readGoodsStates: a ground on a record's goods is checked against what its goods rest on" },
+];
+
 const UNDECLARED = {
   // The verbatim forward is named in the prompt only when job.rawRequest exists — and matter-frame,
   // unlike blind-frame, never declared it at all (stages.mjs "matter-frame": []).
@@ -224,6 +240,7 @@ const UNDECLARED = {
   // and one that built it and lost it in the copy refuses by name. Listing it costs nothing on the first and
   // is the whole point on the second.
   "register-digest": (P) => [
+    ...placementSetAsideReads(P),
     { path: P.registerHitList,
       why: "the digest's own message names this file and asks the model to mark lines on it (hit-list.mjs reads the marks back); without it in the copy a marking lands nowhere and the stage passes having been given a different input than the real one" },
   ],
@@ -231,6 +248,7 @@ const UNDECLARED = {
   // non-zero count (stages.mjs synthesis message). Undeclared on purpose — it is aim-attention only and
   // must never move a freshness stamp — but a sandbox without it hands a different prompt.
   synthesis: (P) => [
+    ...placementSetAsideReads(P),
     { path: P.enforcerSignals, kind: "conditional",
       why: "named in the prompt only when ctx.enforcerSignals > 0; aim-attention telemetry, deliberately outside the freshness map" },
     // The job's own scope. The prompt never names it, so nothing declared it, and the sandbox rebuilt the

package/driver/stages.mjs

@@ -16,7 +16,7 @@
 
 import { join, basename } from "node:path";
 import { driverRel } from "../shared/driver-dir.mjs";   //
-import { researchAnsweredBlock } from "./research-answers.mjs";   // the research an earlier attempt got, handed to a later one
+import { researchAnsweredBlock } from "./research-answers.mjs"; import { savedFindingsBlock } from "./saved-findings-block.mjs";   // the research an earlier attempt got, and the findings it saved, handed to a later one
 import { awaitsReadingTurn } from "../providers/_shared/plan-guards.mjs";   // — a guard the dictation misreads is a question the model never knows it may ask
 import { isNonLatinTerm } from "../providers/_shared/script-form.mjs";
 import { latinQuestionsOfRomanisedForm } from "./register-plan.mjs";   // sentence 3 — the Latin question a script question repeats
@@ -3099,7 +3099,7 @@ export const STAGES = {
         why: "THE SECOND frame_scope_missing. The driver holds the value in _driver/framework.json, writes it into the dispatch, asks the model to retype it, and fails the file when the retyping does not match its own copy. The audit table groups it under the tool-written envelope row; pre-bound is the sharper discharge and either removes it from the model",
       },
     },
-    message: ({ paths: P, job, customerUnknown, profile, intakeAsks, enforcerSignals, framework, frameworkMethod, jxAim, registerOnly, crowdContext, dispatchBlocks, findingsSurface, depth, placementSetAsides, researchAnswered }) => lines(
+    message: ({ paths: P, job, customerUnknown, profile, intakeAsks, enforcerSignals, framework, frameworkMethod, jxAim, registerOnly, crowdContext, dispatchBlocks, findingsSurface, depth, placementSetAsides, researchAnswered, savedSynthesis }) => lines(
       // C4 — pharma matters (class 5 / pharma-shaped goods) FORCE-READ the field module: the
       // therapeutic-goods discipline, no-use ≠ safety (pipelines run 5-10y), practitioner/pharmacist
       // confusion. Conditional read (frameworkFor pattern); doctrine TABLES live elsewhere, untouched.
@@ -3122,7 +3122,7 @@ export const STAGES = {
       // WS2 (spec 11) — ENFORCED, not advisory: validators.narrative HARD-REJECTS this file if a
       // use-dependent finding above the framework's lowest band asserts a use-negative without a searched
       // source line. So actually run the query.
-      `USE-CHECK (enforced): run the scoped use check (phase2-execution.md Step 3.5) on EVERY finding banded ${(framework && materialBandPhrase(framework)) || "medium risk or higher"} — the rungs this framework rates medium risk or higher; a lower rung is not checked — and ask in the SAME query for the owner's enforcement record (oppositions, disputes or court actions over this mark or a similar one). After the search, use is "confirmed" or "not-confirmed", never "unknown". What the query finds about enforcement is a LEAD under ENFORCEMENT AUTHORITY below: enforcer basis "inferred-from-signal", its URL cited inline in that finding's prose; where it finds none, the enforcer is "low" with basis "inferred-from-signal" and the finding says the search found no enforcement record. ALSO, for EVERY finding whose mitigant/verdict turns on the ABSENCE of use (regardless of its band) ("not in actual use", "unused", "no marketplace use found", non-use revocation/cancellation as the mitigant, "owner's use unknown"), run ONE scoped \`perplexity_research\` query (owner + mark + the goods/field) and END that finding's actual-use line with a literal "- **Use-check source:** <result URL | "perplexity_research — no result">" line. Mirror the result into the matching # Actions item (the deferred "confirm the owner's use" becomes a stated result). NEVER assert a use-negative you did not search — an inference from the owner's profile is not a searched result. On a perplexity outage write "- **Use-check source:** perplexity_research — no result" and proceed (the run still delivers). ALSO populate that finding's use_check field in findings.json: {"source": "<the result URL | perplexity_research — no result>"} — the structured field is the authoritative cite the report renders from (the prose line is for narrative readability).`,
+      `USE-CHECK (enforced): run the scoped use check (phase2-execution.md Step 3.5) on EVERY finding banded ${(framework && materialBandPhrase(framework)) || "medium risk or higher"} — the rungs this framework rates medium risk or higher; a lower rung is not checked — and ask in the SAME query for the owner's enforcement record (oppositions, disputes or court actions over this mark or a similar one). ${USE_CHECK_ANSWERS_HELD} After the search, use is "confirmed" or "not-confirmed", never "unknown". What the query finds about enforcement is a LEAD under ENFORCEMENT AUTHORITY below: enforcer basis "inferred-from-signal", its URL cited inline in that finding's prose; where it finds none, the enforcer is "low" with basis "inferred-from-signal" and the finding says the search found no enforcement record. ALSO, for EVERY finding whose mitigant/verdict turns on the ABSENCE of use (regardless of its band) ("not in actual use", "unused", "no marketplace use found", non-use revocation/cancellation as the mitigant, "owner's use unknown"), run ONE scoped \`perplexity_research\` query (owner + mark + the goods/field) unless an answer this run already holds answers that question, and END that finding's actual-use line with a literal "- **Use-check source:** <result URL | "perplexity_research — no result">" line. Mirror the result into the matching # Actions item (the deferred "confirm the owner's use" becomes a stated result). NEVER assert a use-negative you did not search — an inference from the owner's profile is not a searched result. On a perplexity outage write "- **Use-check source:** perplexity_research — no result" and proceed (the run still delivers). ALSO populate that finding's use_check field in findings.json: {"source": "<the result URL | perplexity_research — no result>"} — the structured field is the authoritative cite the report renders from (the prose line is for narrative readability).`,
       // Spec-v3 A4 — ENFORCED the same way (validators.narrative): own-rights reliance needs its evidence.
       // PR-8 review fix: synthesis holds the FROZEN band, not the live register — and the band is class-
       // and mark-text-scoped to this matter's dispatched slices, so the client's OWN house-mark
@@ -3150,7 +3150,7 @@ export const STAGES = {
       // (house-brand attachment / seasonality / scale). Context, never a rule that decides a finding.
       job?.campaignShape ? `Stated campaign shape (verbatim from intake — how the mark will be deployed; facts, not judgment): ${job.campaignShape}` : "",
       `Inputs: register findings ${P.registerFindings}${registerOnly ? "" : `; common-law ${P.commonLaw}`}; placements ${P.placement} (structured tiers + reasons: ${P.placementModel}); matter frame ${P.matterContext}; manifest ${P.variantManifest}.`,
-      placementSetAsideBlock(placementSetAsides),
+      placementSetAsideBlock(placementSetAsides), WRITER_STARTS_FROM_THE_WORK, WRITER_RECORDS_AS_IT_GOES,
       // The skeptic's shipped sentence, word for word: a granted tool is named, or the seat cannot know it holds it.
       `Re-read any of this run's own artifacts with the \`search_run_artifacts\` tool — ONE file per call, named relative to the run directory (e.g. "register-findings.md"), with \`terms\` as literal substrings OR-matched per line.`,
       PLACEMENT_BORDERLINE_NOTE,
@@ -3208,8 +3208,8 @@ export const STAGES = {
       // judgment-relocation (2026-06-23): you are Layer B — the ONE judgment layer. The funnel ENUMERATED the
       // dangerous named band or reported HONEST INCOMPLETENESS; you read the complete material and decide
       // relevance, risk, sufficiency and prioritisation. PR-8: the reading goes through the band tools
-      // (shape whole + logged lookups) — nothing was sampled away upstream, and nothing is sliced by hand.
-      BAND_READING_CONTRACT_AFTER_PLACEMENT,
+      // (logged lookups, as an assessment needs them) — nothing was sampled away upstream, nothing sliced by hand.
+      BAND_READING_CONTRACT_FOR_THE_WRITER,
       // PR-8: synthesis holds NO live register tools — by design, never an outage. The funnel owns
       // enumeration; a register check this stage still wants is either answerable from the frozen
       // material (the band tools) or it is NEW SEARCH WORK, which enters only through the supplemental
@@ -3438,13 +3438,13 @@ export const STAGES = {
       // MEANS — the net contract, the band contract, the meters, the disposition logic, the voice
       // rules. What goes is the seat formatting them into a file for the driver to read back.
       `RECORD YOUR WORK WITH \`record_synthesis\`. THE DISPATCH NAMES NO FILE FOR YOU TO WRITE, deliberately — the driver renders both the narrative and the findings record from what you send. You hold no Write or Edit tool for either and nothing you write by hand is read.`,
-      `WHAT THE CALL TAKES. \`narrative\`: your CROSS-FINDING read as sections — \`spine\` (the dominant-element spine), \`verdict\` (what the findings together mean for this client), \`coverage.read\` (the honest coverage prose) and \`calibration\` ([{challenge, answer}]). \`findings\`: the findings document exactly as specified above — schema_version, rated_under_framework, findings[], coverage[], ask_answers[] and the top-level registers. It is the same values it always was; it arrives on the call instead of as a file you write.`,
+      `WHAT THE CALL TAKES. \`narrative\`: your CROSS-FINDING read as sections — \`spine\` (the dominant-element spine), \`verdict\` (what the findings together mean for this client), \`coverage.read\` (the honest coverage prose) and \`calibration\` ([{challenge, answer}]). \`findings\`: the findings document exactly as specified above — schema_version, rated_under_framework, findings[], coverage[], ask_answers[] and the top-level registers. It is the same values it always was; it arrives on the call instead of as a file you write. \`save_findings\`: a finding you have completed, alone or a few at a time, saved before the whole record exists; each is checked as the record checks a finding and kept as soon as it passes, and the call carrying \`narrative\` with \`findings\` takes every saved finding for a position it does not carry.`,
       `THE PER-FINDING WRITE-UPS ARE NOT A FIELD, and that is a ruling rather than an omission: the report card holds the single authored wording for a finding and the typed fields carry the reads it is written from. Do not restate a finding's reasoning in the narrative sections — the spine is what the findings mean TOGETHER, which is the read no other artifact on this run holds.`,
       `COVERAGE ROWS AND ASK ANSWERS ARE SENT ONCE, ON THE RECORD, AND THE DRIVER RENDERS THEM INTO THE NARRATIVE TOO. Do not repeat them as narrative sections — a second authored copy is refused, because two copies of one statement can disagree and it is the record's copy that ships to the report, the workbook and the portal.`,
       `YOUR COVERAGE ROWS ARE JOINED TO THIS RUN'S PLAN-EXECUTION RECEIPT AS YOU SEND THEM. \`confirmed-clean\` asserts a search ran and came back empty, so a confirmed-clean row naming a slice the receipt does not record as executed is REFUSED — in this turn, where restating it costs nothing, rather than at a gate whose only repair is re-asking this whole stage. Name the area as the receipt names the slice. The honest alternatives are \`coverage-limited\` and \`not-searched\`, and neither is a worse answer than a clean claim that is not true.`,
       // THE RESEARCH AN EARLIER ATTEMPT GOT, handed on as a file (research-answers.mjs). Last, and absent on a first
       // attempt, whose message is unchanged.
-      researchAnsweredBlock(researchAnswered),
+      researchAnsweredBlock(researchAnswered), savedFindingsBlock(savedSynthesis),
     ),
     // A FRESH RETRY IS REBUILT, so it is handed the research its earlier attempts got. Nothing else in this stage's
     // context changes between attempts: the findings surface and its positions are frozen for the stage, and placement's
@@ -4831,3 +4831,31 @@ export const REFUTATION_RECORDING_LINES = Object.freeze([
   `TYPE EACH CORRECTION: \`kind\` is ONE of coverage-disposition | fact | rating | narrative — pick the one your own legal read says the correction IS: coverage-disposition (a coverage row / disposition placement is wrong or dishonest), fact (a factual defect — record values, owners, statuses, dates, grounding), rating (a band/rating you challenge), narrative (prose, structure or voice of the narrative). DECLARE the kind from what the correction is about, never from how severe it is.`,
   `A BLOCKING verdict REQUIRES at least one flag. A refusal to sign that names nothing is refused by the call itself, in this turn, rather than at the gate — where its only repair is one forced re-ask of this whole stage.`,
 ]);
+
+// ── THE WRITER WRITES FROM THE WORK IT IS HANDED (ruled 2026-10-27) ─────────────────────────────────────────────────
+//
+// On a test run of a crowded matter the writer's second try made 1,095 record reads of 707 distinct records and 117
+// web research calls, and recorded nothing before its time ran out. It was re-reading the matter from the start: the
+// band's shape, then each position's records one by one, then the owners. The steps before it had already settled
+// relevance and kept the evidence. So the writer starts from that work: it inherits supported decisions, completes the
+// assessment that is its own, and reads or searches further only where the evidence it holds does not answer a
+// question. Its duties do not change: the ratings, the cross-finding read and the required checks stay with it.
+export const WRITER_STARTS_FROM_THE_WORK = lines(
+  "Start from the retained entries, the recorded decisions, and the evidence this run already holds. Use completed work in your judgment and write what the findings mean together for this client. Complete the legal and practical assessment that remains yours under the framework.",
+  "Reopen a settled decision only for identified contrary evidence or an identified error in its reasoning. Complete an outstanding required question from the evidence already held; read or search further only where that evidence does not answer it. Do not repeat the investigation because a new stage or attempt has started.",
+  "Assess each retained position on its relevant evidence. A list of its constituent records does not require you to open every record. Open an additional record when a difference in its goods, status, priority, territory, identity, or other material evidence could change the assessment and the supplied evidence does not resolve it. Missing or incomplete evidence does not establish an exclusion or a clean result.",
+);
+// The band as the writer is told of it: what the tools are for, never a read it owes. The contract the steps before it
+// read begins "call `band_shape` FIRST" and says each part of a large shape names the next call. The standards that
+// contract sets for any reading are kept word for word, cut from it so the two cannot drift apart. The name keeps
+// "BAND_READING_CONTRACT" in it: the stages that read the band are found by it (BAND_READING_STAGES, band-size.mjs).
+export const BAND_READING_STANDARDS = BAND_READING_CONTRACT.slice(BAND_READING_CONTRACT.indexOf("A crowd descriptor is an open slice"));
+export const BAND_READING_CONTRACT_FOR_THE_WRITER = "THE REGISTER BAND: Use the band tools (`band_shape`, `band_lookup`, `band_record`) when a specific assessment needs evidence beyond the material handed to you. The available groups and pages are ways to find that evidence, not a list you must read to completion. "
+  + BAND_READING_STANDARDS;
+// An answer the run already holds can be a finding's check (ruled 2026-10-27): a use-check source needs evidence, not
+// a fresh call. The triggers are unchanged. Step 3.5 of phase2-execution.md carries the same words.
+export const USE_CHECK_ANSWERS_HELD = "Apply the existing triggers for actual-use, enforcement, and owner checks after the relevant legal assessment. First use a suitable answer already held by this run, including an earlier stage or attempt, where it answers the same owner, mark, goods, territory, and material time question. A source requirement is not a requirement for a new call. One answer may support several findings only where it answers each finding's question. Ask only what remains unanswered and record the result against every finding it supports.";
+// Saving as it goes (ruled 2026-10-27): a try that is stopped keeps the findings and exclusions it accepted, and the
+// next try continues from them. Exclusions already go through record_declination in batches; record_synthesis takes
+// a part of the findings before the whole document exists.
+export const WRITER_RECORDS_AS_IT_GOES = "Record completed findings (`record_synthesis`) and exclusions (`record_declination`) as you complete them, individually or in small groups; do not wait for the whole report. On a resumed attempt, continue from this run's accepted work and complete what remains. Revise accepted work only for identified contrary evidence, a reasoning error, or an applicable change in the instructions. Finish the overall conclusions against the complete set before declaring the assessment complete.";