clearotron 0.4.1 → 0.5.0-beta.0

package/driver/repair-scope.mjs

@@ -0,0 +1,327 @@
+// 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
+//
+// repair-scope.mjs — WHAT A DELIVERY-CHECK REPAIR CHANGED, AND WHAT RESTS ON IT.
+//
+// After the delivery check finds a fault in the narrative, the writer repairs its record, and the reviewer
+// used to read the whole narrative again, cold, as if no review had happened. The review after a repair
+// 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 by the writer. This module works out the first two from the writer's
+// saved record before and after the repair, by VALUE: a file written again with the same values is no
+// change, and a reworded coverage area is one line removed and one added, said rather than hidden.
+//
+// PURE, apart from three thin IO helpers at the bottom. It holds no sentence the model reads: the composer
+// in repair-composers.mjs renders the list from what this returns, and the labels below are the item names
+// that list prints and the reviewer is asked to repeat, so a flag can be joined back to its item.
+import { readFileSync, writeFileSync, renameSync, rmSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { driverDir } from "../shared/driver-dir.mjs";
+import { synthesisCallPaths } from "./synthesis-record.mjs";
+import { REPORT_LINE_KEY, REPORT_LINE_LABEL } from "./corrections-feedforward.mjs";
+
+const isObj = (v) => v != null && typeof v === "object" && !Array.isArray(v);
+const collapse = (s) => String(s).replace(/\s+/g, " ").trim();
+
+/**
+ * One value's identity for "did it change": strings whitespace-collapsed, objects key-sorted, arrays in
+ * order, an absent key the same as an absent value. PURE.
+ */
+export function canonicalValue(v) {
+  if (v === undefined || v === null) return "null";
+  if (typeof v === "string") return JSON.stringify(collapse(v));
+  if (typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return `[${v.map(canonicalValue).join(",")}]`;
+  return `{${Object.keys(v).filter((k) => v[k] !== undefined).sort()
+    .map((k) => `${JSON.stringify(k)}:${canonicalValue(v[k])}`).join(",")}}`;
+}
+const same = (a, b) => canonicalValue(a) === canonicalValue(b);
+
+/** The narrative's prose sections, with the titles the narrative renders them under. */
+export const NARRATIVE_PROSE = Object.freeze([
+  Object.freeze({ key: "verdict", title: "Verdict", read: (n) => n?.verdict }),
+  Object.freeze({ key: "spine", title: "The spine", read: (n) => n?.spine }),
+  Object.freeze({ key: "coverage", title: "Coverage", read: (n) => n?.coverage?.read }),
+  Object.freeze({ key: "calibration", title: "Calibration challenges", read: (n) => n?.calibration }),
+]);
+
+/** A section's value as one line of text, the challenges joined in order. PURE. */
+export function sectionText(v) {
+  if (v == null) return "";
+  if (Array.isArray(v)) return v.map((c) => collapse(`${c?.challenge ?? ""} ${c?.answer ?? ""}`)).filter(Boolean).join(" ");
+  return collapse(v);
+}
+
+// ── THE LABELS: one name per item, printed in the list and repeated by the reviewer ──────────────────
+export const LABEL = Object.freeze({
+  finding: (n) => `finding ${n}`,
+  coverage: (row) => REPORT_LINE_LABEL.coverage(row),
+  section: (title) => `the narrative's "${title}" section`,
+  "coverage-judgment": () => "the coverage judgment",
+  action: (a) => REPORT_LINE_LABEL.actions(a),
+  answer: (ask) => `the answer to "${ask}"`,
+  "mark-assessment": (key) => `the mark assessment's ${key}`,
+  "four-answers": (key) => `the four answers' ${key}`,
+  "context-notes": () => "the context notes",
+});
+
+const byKey = (list, keyOf) => {
+  const m = new Map();
+  for (const x of Array.isArray(list) ? list : []) m.set(keyOf(x), x);
+  return m;
+};
+const keyedChanges = (before, after, keyOf) => {
+  const b = byKey(before, keyOf), a = byKey(after, keyOf), out = [];
+  for (const [k, x] of a) {
+    if (!b.has(k)) out.push({ key: k, change: "added", before: null, after: x });
+    else if (!same(b.get(k), x)) out.push({ key: k, change: "changed", before: b.get(k), after: x });
+  }
+  for (const [k, x] of b) if (!a.has(k)) out.push({ key: k, change: "removed", before: x, after: null });
+  return out;
+};
+const objectKeyChanges = (before, after) => {
+  const keys = new Set([...Object.keys(isObj(before) ? before : {}), ...Object.keys(isObj(after) ? after : {})]);
+  return [...keys].sort().filter((k) => !same(before?.[k], after?.[k]))
+    .map((k) => ({ key: k, before: before?.[k] ?? null, after: after?.[k] ?? null }));
+};
+
+/**
+ * What the repair changed, from two accepted-call params `{narrative, findings}` in the model's numbering.
+ *
+ * `whole` is true when there is nothing to compare against, or when the record's version or framework moved:
+ * then nothing here can say which statements rest on what, and the review stays whole. The writer's own
+ * `corrections` note is not content a reader is given, so it is not compared. PURE.
+ */
+export function changedContent(before, after) {
+  const none = { findings: [], lines: [], registers: [], sections: [], whole: false, why: null };
+  const bf = before?.findings, af = after?.findings;
+  if (!isObj(bf)) return { ...none, whole: true, why: "no-base" };
+  if (!isObj(af)) return { ...none, whole: true, why: "no-record" };
+  for (const k of ["schema_version", "rated_under_framework"]) {
+    if (!same(bf[k], af[k])) return { ...none, whole: true, why: `${k}-changed` };
+  }
+  const findings = keyedChanges(bf.findings, af.findings, (f) => f?.ordinal)
+    .map(({ key, change, before: b, after: a }) => ({
+      ordinal: key, change,
+      fields: change === "changed" ? objectKeyChanges(b, a).map((x) => x.key) : [],
+      before: b, after: a,
+    }))
+    .sort((x, y) => Number(x.ordinal) - Number(y.ordinal));
+  const lines = keyedChanges(bf.coverage, af.coverage, REPORT_LINE_KEY.coverage)
+    .map((x) => ({ ...x, area: (x.after ?? x.before)?.area ?? "" }));
+  const registers = [];
+  for (const x of keyedChanges(bf.actions, af.actions, REPORT_LINE_KEY.actions))
+    registers.push({ kind: "action", label: LABEL.action(x.after ?? x.before), ...x });
+  for (const x of keyedChanges(bf.ask_answers, af.ask_answers, (q) => collapse(q?.ask ?? "")))
+    registers.push({ kind: "answer", label: LABEL.answer((x.after ?? x.before)?.ask ?? ""), ...x });
+  for (const x of objectKeyChanges(bf.four_answers, af.four_answers))
+    registers.push({ kind: "four-answers", label: LABEL["four-answers"](x.key), change: "changed", ...x });
+  for (const x of objectKeyChanges(bf.mark_assessment, af.mark_assessment))
+    registers.push({ kind: "mark-assessment", label: LABEL["mark-assessment"](x.key), change: "changed", ...x });
+  if (!same(bf.coverage_judgment, af.coverage_judgment))
+    registers.push({ kind: "coverage-judgment", label: LABEL["coverage-judgment"](), key: "coverage_judgment", change: "changed",
+      before: bf.coverage_judgment ?? null, after: af.coverage_judgment ?? null });
+  if (!same(bf.context_notes, af.context_notes))
+    registers.push({ kind: "context-notes", label: LABEL["context-notes"](), key: "context_notes", change: "changed",
+      before: bf.context_notes ?? null, after: af.context_notes ?? null });
+  const sections = [];
+  for (const s of NARRATIVE_PROSE) {
+    const b = s.read(before?.narrative), a = s.read(after?.narrative);
+    if (!same(b, a)) sections.push({ key: s.key, title: s.title, before: sectionText(b), after: sectionText(a) });
+  }
+  return { findings, lines, registers, sections, whole: false, why: null };
+}
+
+/** Nothing changed: a file written again with the same values. PURE. */
+export const isEmptyChange = (c) => Boolean(c) && !c.whole
+  && !c.findings.length && !c.lines.length && !c.registers.length && !c.sections.length;
+
+/**
+ * The statements handed with the change because they rest on it, as they read now. The rule is typed and
+ * uses no prose matching; the reviewer judges any other dependent statement itself.
+ *   · whenever anything changed: every prose section that did not itself change, and the coverage judgment;
+ *   · when findings changed: every action, answer and four-answers row whose `ordinals` name one of them.
+ * PURE.
+ */
+export function restingOn(changed, after) {
+  if (!changed || changed.whole || isEmptyChange(changed)) return [];
+  const out = [];
+  const changedSections = new Set(changed.sections.map((s) => s.key));
+  for (const s of NARRATIVE_PROSE) {
+    const text = sectionText(s.read(after?.narrative));
+    if (!changedSections.has(s.key) && text) out.push({ kind: "section", key: s.key, title: s.title, label: LABEL.section(s.title), text });
+  }
+  const af = after?.findings ?? {};
+  const changedRegister = (kind, key) => changed.registers.some((r) => r.kind === kind && String(r.key) === String(key));
+  if (af.coverage_judgment != null && !changedRegister("coverage-judgment", "coverage_judgment"))
+    out.push({ kind: "coverage-judgment", label: LABEL["coverage-judgment"](), value: af.coverage_judgment });
+  const moved = new Set(changed.findings.map((f) => Number(f.ordinal)));
+  if (moved.size) {
+    const names = (row) => (Array.isArray(row?.ordinals) ? row.ordinals.map(Number) : []).filter((o) => moved.has(o));
+    for (const a of Array.isArray(af.actions) ? af.actions : []) {
+      const hit = names(a);
+      if (hit.length && !changedRegister("action", REPORT_LINE_KEY.actions(a)))
+        out.push({ kind: "action", key: REPORT_LINE_KEY.actions(a), label: LABEL.action(a), ordinals: hit, text: collapse(a?.text ?? "") });
+    }
+    for (const q of Array.isArray(af.ask_answers) ? af.ask_answers : []) {
+      const hit = names(q);
+      if (hit.length && !changedRegister("answer", collapse(q?.ask ?? "")))
+        out.push({ kind: "answer", key: collapse(q?.ask ?? ""), label: LABEL.answer(q?.ask ?? ""), ordinals: hit, text: collapse(q?.answer ?? "") });
+    }
+    for (const [k, v] of Object.entries(isObj(af.four_answers) ? af.four_answers : {})) {
+      const hit = names(v);
+      if (hit.length && !changedRegister("four-answers", k))
+        out.push({ kind: "four-answers", key: k, label: LABEL["four-answers"](k), ordinals: hit, text: collapse(v?.read ?? "") });
+    }
+  }
+  return out;
+}
+
+/**
+ * Every item the review is about, with the one label the list prints for it: the changed items first, then
+ * the statements resting on them. A finding the delivery fold renumbered carries its delivered number too.
+ * PURE.
+ */
+export function scopeItems(changed, resting, foldMap = null) {
+  const delivered = (n) => {
+    const m = foldMap?.modelToFolded?.[String(n)];
+    return m != null && Number(m) !== Number(n) ? Number(m) : null;
+  };
+  const items = [];
+  for (const f of changed?.findings ?? []) items.push({ kind: "finding", ordinal: Number(f.ordinal), delivered: delivered(f.ordinal), label: LABEL.finding(f.ordinal), change: f.change, role: "changed" });
+  for (const l of changed?.lines ?? []) items.push({ kind: "coverage", key: l.key, label: LABEL.coverage(l.after ?? l.before), change: l.change, role: "changed" });
+  for (const s of changed?.sections ?? []) items.push({ kind: "section", key: s.key, label: LABEL.section(s.title), change: "changed", role: "changed" });
+  for (const r of changed?.registers ?? []) items.push({ kind: r.kind, key: r.key, label: r.label, change: r.change, role: "changed" });
+  for (const r of resting ?? []) items.push({ kind: r.kind, key: r.key ?? null, label: r.label, ordinals: r.ordinals ?? null, role: "resting" });
+  return items;
+}
+
+/** Whether a delivered number differs from the model's for any listed finding. PURE. */
+export const anyRenumbered = (items) => (items ?? []).some((i) => i.kind === "finding" && i.delivered != null);
+
+/**
+ * The one target a flag names. A finding by its `on` ordinals, in the model's numbering as the review was
+ * asked; anything else by a flag text that BEGINS with one of the list's exact labels, the longest first. A
+ * label elsewhere in the text, or a quoted phrase, is not a target: matching prose is how a rewrite lands on
+ * the wrong thing. Otherwise the target is none. PURE.
+ */
+export function resolveTarget(flag, items) {
+  const on = Array.isArray(flag?.on) ? flag.on.map(Number).filter((n) => Number.isInteger(n) && n > 0) : [];
+  if (on.length) return { kind: "finding", ordinals: on, label: on.map(LABEL.finding).join(", ") };
+  const text = String(flag?.text ?? "").trim();
+  const labels = [...new Set((items ?? []).filter((i) => i.kind !== "finding").map((i) => i.label))]
+    .sort((a, b) => b.length - a.length);
+  const hit = labels.find((l) => text.startsWith(l));
+  if (hit) {
+    const item = items.find((i) => i.label === hit);
+    return { kind: item.kind, key: item.key ?? null, label: hit };
+  }
+  return { kind: "none", label: null };
+}
+
+/**
+ * The three classes the scope decision asks for: MAPPED (the target is a changed item or a statement resting
+ * on one), UNRELATED (the target resolved, to something outside both), UNRESOLVED (no target). Every point
+ * goes to the correction either way; the class is recorded, so how often the review steps outside its scope
+ * can be measured. PURE.
+ */
+export function classifyPoints(flags, items) {
+  const findings = new Set((items ?? []).filter((i) => i.kind === "finding").map((i) => i.ordinal));
+  const restingFindings = new Set((items ?? []).flatMap((i) => (i.role === "resting" && i.ordinals) ? i.ordinals : []));
+  const labels = new Set((items ?? []).filter((i) => i.kind !== "finding").map((i) => i.label));
+  return (flags ?? []).map((flag, i) => {
+    const target = resolveTarget(flag, items);
+    const cls = target.kind === "none" ? "unresolved"
+      : target.kind === "finding" ? (target.ordinals.some((o) => findings.has(o) || restingFindings.has(o)) ? "mapped" : "unrelated")
+      : (labels.has(target.label) ? "mapped" : "unrelated");
+    return { n: i + 1, kind: flag?.kind ?? null, on: Array.isArray(flag?.on) ? flag.on : null, target, class: cls };
+  });
+}
+
+/**
+ * Which of the reviewer's files the repair changed, for its inputs line: the narrative when a section, a
+ * coverage line or an answer moved (the narrative renders all three), the findings record when anything in it
+ * moved. PURE.
+ */
+export function changedInputsOf(changed, { narrative, findings }) {
+  if (!changed || changed.whole) return [];
+  const inRecord = changed.findings.length || changed.lines.length || changed.registers.length;
+  const inNarrative = changed.sections.length || changed.lines.length || changed.registers.some((r) => r.kind === "answer");
+  return [inNarrative ? narrative : null, inRecord ? findings : null].filter(Boolean);
+}
+
+// ── IO: the repair base, and the review's own record ────────────────────────────────────────────────
+const writeAtomic = (file, text) => {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+};
+
+/** Where the writer's accepted record is kept from just before the delivery-check repair. */
+export function repairBasePath(runDir) {
+  return join(synthesisCallPaths(String(runDir ?? "")).dir, "accepted-before-repair.json");
+}
+
+/**
+ * Keep the writer's accepted record as it stands, just before the delivery-check repair. With no accepted
+ * record there is no base, and any earlier copy is removed so it cannot stand for this repair. Never throws.
+ * Returns whether a base was kept.
+ */
+export function snapshotRepairBase(runDir) {
+  const at = repairBasePath(runDir);
+  try {
+    const bytes = readFileSync(synthesisCallPaths(String(runDir ?? "")).accepted, "utf8");
+    writeAtomic(at, bytes);
+    return true;
+  } catch {
+    try { rmSync(at, { force: true }); } catch { /* nothing to remove */ }
+    return false;
+  }
+}
+
+/** The kept base's params, or null. Never throws. */
+export function readRepairBase(runDir) {
+  try { return JSON.parse(readFileSync(repairBasePath(runDir), "utf8"))?.params ?? null; } catch { return null; }
+}
+
+/** The review after a repair's own record: what it was handed, how each point was classed, what the pass did. */
+export function postRepairRecordPath(runDir) { return driverDir(String(runDir ?? ""), "post-repair-review.json"); }
+
+export function writePostRepairRecord(runDir, rec) {
+  try { writeAtomic(postRepairRecordPath(runDir), JSON.stringify({ ts: new Date().toISOString(), ...rec }, null, 2) + "\n"); return true; }
+  catch { return false; }
+}
+
+/**
+ * The review's list, as the values its composer renders: each change with its before and after, each
+ * statement resting on one, whether a delivered number differs, and which kinds of evidence to name. A
+ * changed finding carries only the fields that moved, and `records` is its `source` as the model saved it.
+ * PURE.
+ */
+export function listForReview(changed, resting, foldMap = null) {
+  const delivered = (n) => {
+    const m = foldMap?.modelToFolded?.[String(n)];
+    return m != null && Number(m) !== Number(n) ? Number(m) : null;
+  };
+  const pick = (f, fields) => Object.fromEntries(fields.map((k) => [k, f?.[k] ?? null]));
+  const changes = [];
+  for (const f of changed?.findings ?? []) {
+    const base = { kind: "finding", change: f.change, ordinal: Number(f.ordinal), delivered: delivered(f.ordinal) };
+    if (f.change === "changed") changes.push({ ...base, fields: f.fields, before: pick(f.before, f.fields), after: pick(f.after, f.fields), records: f.after?.source ?? null });
+    else if (f.change === "added") changes.push({ ...base, after: f.after, records: f.after?.source ?? null });
+    else changes.push({ ...base, before: f.before });
+  }
+  for (const l of changed?.lines ?? []) changes.push({ kind: "coverage", change: l.change, label: LABEL.coverage(l.after ?? l.before), before: l.before, after: l.after });
+  for (const s of changed?.sections ?? []) changes.push({ kind: "section", change: "changed", title: s.title, before: s.before, after: s.after });
+  for (const r of changed?.registers ?? []) {
+    const val = (x) => (r.kind === "answer" ? (x?.answer ?? null) : x);
+    changes.push({ kind: r.kind, change: r.change, label: r.label, before: val(r.before), after: val(r.after) });
+  }
+  return {
+    changes,
+    resting: resting ?? [],
+    renumbered: changes.some((c) => c.kind === "finding" && c.delivered != null),
+    coverageChanged: changes.some((c) => c.kind === "coverage"),
+    evidence: { coverage: changes.some((c) => c.kind === "coverage"), finding: changes.some((c) => c.kind === "finding") },
+  };
+}

package/driver/repair-targets.mjs

@@ -0,0 +1,92 @@
+// 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
+// repair-targets.mjs — which part of the delivered report holds a delivery-check fault, so its repair can edit it.
+//
+// The report is assembled from parts that different writers own: the overview, which the report-overview step
+// writes; each full card, which its own card step writes; and lines that code composes from the findings record —
+// each card's finding sentence, every short entry and every grouped line. The pre-delivery check reads the assembled
+// report, and most of its prose checks name no finding. A fault that names none went to the overview's repair, which
+// cannot edit a card, so a fault inside a card shipped after a repair that could not reach it, and the overview was
+// rewritten for nothing.
+//
+// So each such fault is located. Its own check runs again on each part's own text, and a part where it fails is a
+// part that holds it: a card's fault goes to that card's repair, carrying the detail the check gives on that card
+// alone, and the overview's goes to the overview's. A fault that only the lines code composes from the record hold is
+// one neither of those repairs can edit: it goes to the writer, whose record those lines are composed from. A fault no
+// single part holds (two cards counting one owner's registrations differently), or one whose check cannot be run on a
+// part, keeps the overview's repair it always had.
+import { readFileSync } from "node:fs";
+import { prescriptionProseChecks, scopeNumberProseChecks, wipoLanguageChecks, countingChecks, countsFromFindings } from "./predelivery-lint.mjs";
+import { netOf, memberLine } from "./write-up-render.mjs";
+
+// The checks that judge a text by itself, run as the delivery check runs them, on one part at a time.
+const ON_A_PART = {
+  "prescription-prose": (text) => prescriptionProseChecks({ reportMd: text }).find((c) => c.surface === "report"),
+  "scope-numbers-in-prose": (text) => scopeNumberProseChecks({ reportMd: text }).find((c) => c.surface === "report"),
+  "wipo-designation-language": (text) => wipoLanguageChecks({ reportMd: text }).find((c) => c.surface === "report"),
+  "counting-consistency": (text) => countingChecks({ report: text })[0],
+  "counting-vs-findings": (text, findings) => countsFromFindings(findings, { report: text })[0],
+};
+export const LOCATED_CHECKS = Object.freeze(Object.keys(ON_A_PART));
+
+/**
+ * Give each report fault the part that holds it. PURE. A fault whose check named its finding goes to that finding's
+ * card, as it always did; one that names none is located.
+ *
+ * `parts` are the texts as their writers wrote them: `cards`, each full card's own file ({ordinal, text}); `overview`,
+ * the overview's own file; and `stamped`, the lines code composes from the record ({ordinal, text}). `findings` is
+ * the record the delivery check judged, for the check that compares a count with it.
+ *
+ * Returns `{cards, overview, stamped, unlocated}`: `cards` maps a card's ordinal to the faults it holds, each with
+ * that card's ordinal and the detail its check gives on that card alone; `overview` holds the faults the overview's
+ * repair is given, those it holds (with its own detail) and those no part holds alone; `stamped` the faults only
+ * lines composed from the record hold, each with `parts`, the finding of each line that holds it and the detail its
+ * check gives on that line; `unlocated` the faults no part holds alone, already counted in `overview`.
+ */
+export function locateReportFaults(failures, { cards = [], overview = null, stamped = [], findings = [] } = {}) {
+  const out = { cards: new Map(), overview: [], stamped: [], unlocated: [] };
+  const fails = (rerun, text) => {
+    if (!String(text ?? "").trim()) return null;
+    const c = rerun(text, findings);
+    return c && c.pass === false ? c : null;
+  };
+  const toCard = (ordinal, fault) => out.cards.set(ordinal, [...(out.cards.get(ordinal) ?? []), fault]);
+  for (const f of failures ?? []) {
+    if (f?.ordinal != null) { toCard(f.ordinal, f); continue; }   // the check named its finding: that card, as it always was
+    const rerun = ON_A_PART[f?.id];
+    if (!rerun) { out.overview.push(f); out.unlocated.push(f); continue; }
+    let held = false;
+    for (const c of cards) {
+      const hit = fails(rerun, c.text);
+      if (!hit) continue;
+      held = true;
+      toCard(c.ordinal, { ...f, ordinal: c.ordinal, detail: hit.detail });
+    }
+    const shell = fails(rerun, overview);
+    if (shell) { held = true; out.overview.push({ ...f, detail: shell.detail }); }
+    if (held) continue;
+    const lines = stamped.map((s) => ({ ordinal: s.ordinal, hit: fails(rerun, s.text) })).filter((x) => x.hit);
+    if (lines.length) { out.stamped.push({ ...f, parts: lines.map((x) => ({ ordinal: x.ordinal, detail: x.hit.detail ?? f.detail })) }); continue; }
+    out.overview.push(f);
+    out.unlocated.push(f);
+  }
+  return out;
+}
+
+/**
+ * The report's parts as their writers wrote them, read from the run. Never throws: a part that cannot be read is left
+ * out, so no fault is placed in it. `plan` is the write-up plan the report was assembled from (pipeline.mjs
+ * planWriteUps): its full cards are the cards' own files, and its short entries and grouped lines, like each card's
+ * finding sentence, are composed from the record.
+ */
+export function reportPartsOf(P, findings, plan) {
+  const read = (at) => { try { return readFileSync(at, "utf8"); } catch { return null; } };
+  const byOrdinal = new Map((findings ?? []).filter((f) => f?.ordinal != null).map((f) => [f.ordinal, f]));
+  const cards = (plan?.cardOrdinals ?? []).map((o) => ({ ordinal: o, text: read(P.reportCard(String(o))) })).filter((c) => c.text != null);
+  const stamped = [
+    ...(plan?.cardOrdinals ?? []).map((o) => ({ ordinal: o, text: netOf(byOrdinal.get(o)) })),
+    ...(plan?.entrySingles ?? []).map((f) => ({ ordinal: f.ordinal, text: read(P.reportCard(String(f.ordinal))) ?? netOf(f) })),
+    ...(plan?.groupedMembers ?? []).map((f) => ({ ordinal: f.ordinal, text: memberLine(f) })),
+  ];
+  return { cards, overview: read(P.reportOverview), stamped, findings };
+}

package/driver/result-noun-fields.mjs

@@ -70,8 +70,8 @@ export const RESULT_NOUN_FIELDS = Object.freeze([
     why: "closure counts derived from the landed set (`qids.filter(q => landed.has(q)).length`) and from the receipt" },
   { file: "driver/pipeline.mjs", noun: "executed", sites: 4, atWriteSite: 3, verdict: "result",
     why: "lengths of the executed set as the join computed it" },
-  { file: "driver/pipeline.mjs", noun: "outcome", sites: 11, atWriteSite: 6, verdict: "result",
-    why: "the one member that reported an invocation — taint-rerun's `r.ok ? \"ok\" : …`, which travels on a StageFailure packet — now carries a `cleared` sibling read from the taint, the remedy 10/5 -> 11/6 at the profile-store receipt's `outcome: pr.outcome`. Classified by READING ITS WRITING SITE, which is profiles.mjs and not this file: the value is one of three literals chosen by a situation the resolver decided (`overlay` and `bundled-fallback` are `pass`, `env-arrived-late` is `blocked`), never a call's return read as a verdict. `bundled-fallback` being `pass` is the point of the whole receipt — a legitimate install that nobody was told about is what this row says out loud." },
+  { file: "driver/pipeline.mjs", noun: "outcome", sites: 12, atWriteSite: 6, verdict: "result",
+    why: "the one member that reported an invocation — taint-rerun's `r.ok ? \"ok\" : …`, which travels on a StageFailure packet — now carries a `cleared` sibling read from the taint, the remedy 10/5 -> 11/6 at the profile-store receipt's `outcome: pr.outcome`. Classified by READING ITS WRITING SITE, which is profiles.mjs and not this file: the value is one of three literals chosen by a situation the resolver decided (`overlay` and `bundled-fallback` are `pass`, `env-arrived-late` is `blocked`), never a call's return read as a verdict. `bundled-fallback` being `pass` is the point of the whole receipt — a legitimate install that nobody was told about is what this row says out loud. 11/6 -> 12/6 at the reviewing lawyer's record, where a read review whose one correction never ran prints its points with `outcome: \"not-checkable\"`: a literal the situation decides (no correction is on record to compare), never a call's return." },
   { file: "driver/pipeline.mjs", noun: "permanent", sites: 1, atWriteSite: 1, verdict: "result",
     why: "`permanent.length` — a count of the classified set" },
   { file: "driver/pipeline.mjs", noun: "recovered", sites: 5, atWriteSite: 5, verdict: "result",
@@ -79,7 +79,7 @@ export const RESULT_NOUN_FIELDS = Object.freeze([
       + "The two newest record what an engine-side re-issue of a missing meaning search actually brought back, counted off the rows "
       + "in hand at the write site rather than from anything the call promised — an attempt that recovered nothing writes 0, which "
       + "is the fact the disclosure downstream depends on" },
-  { file: "driver/pipeline.mjs", noun: "settled", sites: 5, atWriteSite: 4, verdict: "result",
+  { file: "driver/pipeline.mjs", noun: "settled", sites: 6, atWriteSite: 4, verdict: "result",
     why: "counts off the union and the doubt ledger" },
   { file: "driver/pipeline.mjs", noun: "verified", sites: 4, atWriteSite: 2, verdict: "result",
     why: "two sites, both measured states rather than calls returning. (1) `rows.filter(r => r.verified).length`, where each row's flag is `srRecords.has(senior.uri)` — a lookup, not a call. (2) the house-element ownership row's `verified: receipt.verified`, which the verifier sets only where a returned register record matched the client's own name AND was live AND carried an instructed class; the lookup CALL returning is a separate field on the same receipt (`reason`), and an unanswered lookup writes this false" },

package/driver/screen-gate.mjs

@@ -231,3 +231,99 @@ export function findScreenGateParseGaps(findingsContent) {
   }
   return gaps;
 }
+
+// ── WHAT EACH POLICED DROP RESTS ON (ruled 2026-10-18) ────────────────────────────────────────────────
+//
+// The gate above asks one question of each in-scope live goods drop: does the run hold, or has it fetched, the
+// record? A record the run holds answers it whether or not the reading step ever opened it: on a register whose
+// screen hydrates every band record, every drop is answered before any step reads a word. A record held is not
+// evidence the model read it. The rule stays exactly as it is; this records, for every drop the rule polices,
+// what its answer stood for, AS IT STOOD WHEN THE GATE JUDGED IT: the goods the drop rested on, the reading the
+// run recorded for the step that wrote the drop, and what the gate then fetched, with the state after those
+// fetches kept apart. Measured after the fetches alone, a record the gate fetched reads as one the run held all
+// along, so the record could never show which fetch the drop's own goods had made unnecessary.
+//
+// WHAT THE READING STEP SAW is every route the reading log records for its sessions: a `band_record` open of
+// the record, and a lookup, a part of the shape or a page of a group that served the record's line with its
+// goods words. "No recorded read" means none of those is in the log for that step. The log is best-effort, and
+// goods can reach a judgment through other permitted inputs, so it is never read as "never read".
+//
+// The counts say how many fetches the rule avoided and how many it added, and how many drops a rule that asked
+// for an opened record would send back instead. Same parser, same rows, same in-scope test as
+// findScreenGateViolations: every policed drop is a violation against an empty fetched set.
+const gateKey = (u) => (typeof u === "string" ? (u.match(URI_RE)?.[0] ?? u).toLowerCase() : "");
+
+/** The drops the gate polices in this findings text, by gate key, in order. PURE. */
+export function policedDropUris(findingsContent = "") {
+  return [...new Set(findScreenGateViolations(findingsContent, new Set()).map((v) => gateKey(v.uri)).filter(Boolean))];
+}
+
+/**
+ * @param findingsContent  the register-findings.md text the gate judged
+ * @param heldBefore       record uris the gate found held or fetched before it fetched anything (gate-keyed)
+ * @param heldAfter        the same after the gate's own fetches
+ * @param before           uri → {goods, source}: the goods evidence (goods-evidence.mjs) as it stood before the gate fetched
+ * @param after            the same after the gate's fetches; defaults to `before`
+ * @param reads            goods-evidence.mjs recordReads: uri → {opened, shown, missed} session sets
+ * @param lines            goods-evidence.mjs linesRead: line key → {band_shape, group_page} session sets
+ * @param lineOf           uri → the band shape line key the record sits on, or null
+ * @param readerStage      the stage that writes the drop rows, matched within a session key ("register-digest")
+ * @param gateFetched      uri → {ok, cause} for each fetch the gate made
+ * @returns {{drops, counts, fetches, alternatives, unnamed}} PURE.
+ */
+export function screenGateEvidence({ findingsContent = "", heldBefore = new Set(), heldAfter = new Set(), before = () => null, after = null,
+  reads = new Map(), lines = new Map(), lineOf = () => null, readerStage = "register-digest", gateFetched = new Map() } = {}) {
+  const policed = findScreenGateViolations(findingsContent, new Set());
+  const unnamed = policed.filter((v) => !v.uri).length;
+  const keyed = (set) => new Set([...(set ?? [])].map(gateKey));
+  const was = keyed(heldBefore), now = keyed(heldAfter);
+  const fetched = new Map([...(gateFetched ?? new Map())].map(([u, r]) => [gateKey(u), r]));
+  const byReader = (sessions) => [...(sessions ?? [])].some((s) => String(s).includes(readerStage));
+  const stateAt = (fn, uri) => { const e = typeof fn === "function" ? fn(uri) : null; return { goods: e?.goods || null, source: e?.source || null }; };
+  const seen = new Set();
+  const drops = [];
+  for (const v of policed) {
+    const uri = gateKey(v.uri);
+    if (!uri || seen.has(uri)) continue;
+    seen.add(uri);
+    const r = reads?.get?.(uri);
+    const line = lines?.get?.(lineOf(uri)) ?? null;
+    const routes = [
+      byReader(r?.opened) && "band_record", byReader(r?.answered) && "band_record:search-answer", byReader(r?.shown) && "band_lookup",
+      byReader(line?.band_shape) && "band_shape", byReader(line?.group_page) && "group_page",
+    ].filter(Boolean);
+    // The search answer's goods, served in full by the record tool where no official record was on file, are their
+    // own reading: more than a line's goods words, and not the official record the drop is policed on.
+    const reading = routes.includes("band_record") ? "opened" : routes.includes("band_record:search-answer") ? "search-answer-read"
+      : routes.length ? "goods-words-shown" : "no-recorded-read";
+    const f = fetched.get(uri);
+    const b = stateAt(before, uri), a = f ? stateAt(after ?? before, uri) : b;
+    drops.push({ uri, mark: v.mark, held_before_gate: was.has(uri), goods_before_gate: b.goods, source_before_gate: b.source, reading, routes,
+      gate_fetch: f ? (f.ok ? "fetched" : "failed") : "none", ...(f && !f.ok && f.cause ? { cause: String(f.cause).slice(0, 160) } : {}),
+      held_after_gate: now.has(uri), goods_after_gate: a.goods, source_after_gate: a.source });
+  }
+  const n = (pred) => drops.filter(pred).length;
+  const counts = {
+    policed: drops.length,
+    held_before_gate: n((d) => d.held_before_gate),
+    opened_by_reader: n((d) => d.reading === "opened"),
+    search_answer_read: n((d) => d.reading === "search-answer-read"),
+    goods_words_shown_only: n((d) => d.reading === "goods-words-shown"),
+    held_no_recorded_open: n((d) => d.held_before_gate && d.reading !== "opened"),
+    held_no_recorded_read: n((d) => d.held_before_gate && d.reading === "no-recorded-read"),
+    gate_fetched: n((d) => d.gate_fetch !== "none"),
+    gate_fetch_failed: n((d) => d.gate_fetch === "failed"),
+    still_unheld: n((d) => !d.held_after_gate),
+  };
+  return {
+    drops, counts, unnamed,
+    fetches: { avoided: counts.held_before_gate, added: counts.gate_fetched },
+    alternatives: {
+      // Were only a record the reading step OPENED to answer the gate: the drops it would send back to that step.
+      read_rule: { would_send_back: counts.held_no_recorded_open },
+      // Were a band row's whole goods to answer it: the fetches the gate made that the drop's own goods, as they
+      // stood when the gate judged it, would have made unnecessary.
+      row_goods_rule: { fetches_not_needed: n((d) => d.gate_fetch !== "none" && d.source_before_gate === "search-row" && d.goods_before_gate === "complete") },
+    },
+  };
+}

package/driver/skills/clearance-common-law/SKILL.md

@@ -392,6 +392,14 @@ Record the same statuses by calling `record_coverage_status`, passing `grid_spec
 - Brightwick "Raising Your Play" marketing presence in EU — coverage was thin, may need a region-specific follow-up
 ```
 
+## At every step: look at what you have before you work on it
+
+Fifty? Read them all. A few hundred? Sort by the client's goods and markets, read the near ones first, list
+the rest. A thousand or more? The field is crowded: read the identical and live ones for the client's
+goods, tell the client it is crowded, and do not write up the rest. Carry forward only what a lawyer would
+raise with the client. Write down what you set aside and why. This applies to the register's answer, to the
+list of records, to the placements, to the off-register sweep and to the write-up alike.
+
 ## Process
 
 Four steps per mark.

package/driver/skills/clearance-register/SKILL.md

@@ -22,10 +22,10 @@ Two modes, chosen by the orchestrator and stated in the spawn `task`:
   the **complete named band + crowd descriptors** cross the firewall as the band JSON.
 - **Digest mode (judgment — Layer B)** — the task gives the paths to the per-axis prose digests (audit
   summaries) and the manifest; the driver has already MERGED the per-axis bands into the run's complete
-  band. The worker reads that COMPLETE band **through the band tools** (`band_shape` first, then
+  band. The worker reads the candidates placement carried forward and their supporting evidence **through the band tools** (`band_shape` first, then
   `band_lookup` / `band_record` — every call lands in the reading audit; never by opening or slicing band
   files), performs all cross-cutting judgment (relevance, owner aggregation, opposition, Option-D),
-  DECIDES SUFFICIENCY, and writes `studio/clearance-search/<slug>/<date>/register-findings.md`.
+  DECIDES SUFFICIENCY, and hands the register-side findings back as typed rows — the driver renders the document the orchestrator synthesises from; the seat writes no file.
 
 Reads (both modes): the variant manifest at `studio/clearance-search/<slug>/<date>/variant-manifest.md` (archetype + risk
 theory), the `matter-context.md` at `studio/clearance-search/<slug>/<date>/matter-context.md` (Phase 0 strategic anchor — names materially-matters jurisdictions, watchlist-owner seeds, off-field sectors), the request context, the active **provider**. The **watchlist-owner seeds are enrichment / additive-surfacing context, not a search or priority filter** — an in-class identical/near-identical incumbent surfaces on field-relevance alone whether or not its owner is named (see `digest.md` Step 5).
@@ -34,7 +34,7 @@ theory), the `matter-context.md` at `studio/clearance-search/<slug>/<date>/matte
 
 Writes:
 - Unit mode — TWO artifacts, both gate-checked, neither optional. `studio/clearance-search/<slug>/<date>/register-units/<axis>.md` is the stage's DECLARED OUTPUT: the driver fails the pass outright when it is absent, and the digest worker reads it as an input. `studio/clearance-search/<slug>/<date>/register-units/<axis>-band.json` is the COMPLETE named band — a JSON array of `enumerated` / `incomplete` blocks (see `unit.md` → *Named-band artifact*) — carrying every record and no clearance verdict. The md narrates and proves nothing on its own: an md narrating a completed sweep while the band its plan entries call for is missing is refused as `named_band_missing`. In plan mode `register_execute_plan` writes the band itself and you never hand-write its blocks.
-- Digest mode: `studio/clearance-search/<slug>/<date>/register-findings.md`. Coverage statuses are NOT a file you write: they ride the `record_coverage` tool into a driver-held record, and the driver renders the `## Coverage ledger` table and its JSON mirror from it (see *Coverage ledger* below and `digest.md` → *Coverage ledger*). Optional: `register-details/` snapshots inside the run-dir.
+- Digest mode: you write no file. The driver renders `studio/clearance-search/<slug>/<date>/register-findings.md` from what you send. Coverage statuses are NOT a file you write: they ride the `record_coverage` tool into a driver-held record, and the driver renders the `## Coverage ledger` table and its JSON mirror from it (see *Coverage ledger* below and `digest.md` → *Coverage ledger*).
 
 Returns to the orchestrator: your **final session message** — a 2–3 line summary (counts + the
 absolute path of the file you wrote). Keep raw character-noise records out of the message and out of any
@@ -118,8 +118,8 @@ is, then read that list in full and decide.
 
 1. Ask again for the identical mark, in the instructed classes, limited to the client's goods words. Read
    that list.
-2. Still a crowd? Ask again with the dominant goods word alone, then one class at a time: the instructed
-   classes first, then the incumbent's (the classes the owners crowding the list file in). Read each list.
+2. Still a crowd? Ask again with the dominant goods word alone, then one class at a time, in the instructed
+   classes. Read each list.
 3. Still a crowd? Ask again one question per market, in the order your dispatch names: the order's own countries;
    on a worldwide order, the customer's priority markets, else the markets the customer's field and brand
    point to, else the major markets. Read those lists.