clearotron 0.4.0 → 0.4.1-beta.0

package/driver/predelivery-lint.mjs

@@ -1205,29 +1205,25 @@ export function narrativeWriteUpChecks({ narrativeMd, findings, depth, manifest,
     maxWords: depth?.narrativeWriteUpWords ?? null });
   // AN UNGRADED PRODUCT EXAMINES NOTHING, AND THAT IS THE ONLY SILENCE THIS CHECK MAY KEEP.
   if (!r.graded) return [];
-  // — A GRADED NARRATIVE THE PARSER CANNOT KEY IS NOT A COMPLIANT ONE. The old line here was
+  // — A GRADED NARRATIVE WITH NO WRITE-UP BLOCK GETS A ROW, NEVER SILENCE. The old line here was
   // `if (!r.total && !r.violations.length) return []`, which returned the SAME empty array for product
-  // 4's correct inertness and for a graded run whose narrative carries no recognisable write-up block.
-  // 6 of 22 graded runs on the box are the second kind, and every one of them read as compliant.
+  // 4's correct inertness and for a graded run whose narrative carries no write-up block at all.
   //
-  // STRUCTURAL, so it reports without sending a seat to fix it. The depth directive tells the seat
-  // WHICH findings get a prose write-up and HOW LONG it may be. It does not ask for the `Finding N —
-  // <mark>` heading this parser keys on, so a narrative without one breaks no rule the seat was given,
-  // and a warm redo would hand it a correction it has no instruction to satisfy. What is wrong here is
-  // that the DEPTH RULES WENT UNVERIFIED — a coverage fact, stated as one.
+  // AND THE ROW SAYS THE RULE DOES NOT APPLY, because it does not (the owner's ruling of 2026-10-01). The
+  // depth rule governs per-finding write-ups: which findings get one, and how long each may be. A
+  // sectional narrative — the spine, the verdict, coverage, calibration — carries none, measured on 36
+  // of 43 saved clearance narratives, so the rule has nothing to govern there. This row used to fail
+  // every such clearance for a heading the directive never asks for, which put an INVESTIGATE line on
+  // nearly every delivery that nobody could act on. Whether the directive should ask for per-finding
+  // write-ups at all is a separate question, held for the synthesis redesign.
   if (!r.total && !r.violations.length) {
     if (!r.findingsTotal)
       return [check("narrative-write-ups", "narrative-depth", surface, true,
         "no findings on this run, so there is nothing to write up")];
-    return [{ ...check("narrative-write-ups:could-not-read", "narrative-depth", surface, false,
-      `this run has ${r.findingsTotal} finding(s) and the narrative carries NO recognisable prose `
-      + "write-up block, so the depth rules were not verified on it — neither the band-rank cut nor the "
-      + "word cap was applied to anything. This is NOT a fault in the narrative: the depth directive "
-      + "states which findings get a prose write-up and how long it may be, and never asks for the "
-      + "heading this check keys on. It means the rule is unenforced on this run."),
-      // The flag rides the FAILURE, as everywhere else here, and it is what stops a warm redo handing
-      // the seat a correction no directive lets it satisfy.
-      structural: true }];
+    return [check("narrative-write-ups", "narrative-depth", surface, true,
+      `the depth rule does not apply to a sectional narrative: this run has ${r.findingsTotal} finding(s) `
+      + "and the narrative carries no per-finding write-up block, so the band-rank cut and the word cap "
+      + "have nothing to govern")];
   }
   const coverage = r.unjoined
     ? ` (${r.examined} of ${r.total} write-ups joined to a finding; ${r.unjoined} could not be, and were not judged for membership)`
@@ -2200,7 +2196,7 @@ export function cardBudgetChecks({ cardFolds }) {
     `assembly folded ${folds.length} surface(s) to the level budgets (moved, never deleted): ${folds.map((f) => `${f.surface} → +${f.movedSentences} sentence(s)/${f.movedWords} word(s) into depth`).join("; ")}`)];
 }
 
-export function runLint({ depth, commonLawGrid, matterContext, clientPartyName, reportMd, clientSummaryMd, narrativeMd, auditMd, recordsByUri, searchedNames, headerName, ratedNames, actionsText, fetchFailures, extraPlatformNames, findings, findingsRaw, actionsRegister, actionsExpected, intakeAsks, askAnswers, cardFolds, verdictDoc, manifest, seniorRights, seniorRightsExpected, markAssessment, markAssessmentExpected, fourAnswers, contentModelExpected, findingsSchemaVersion, placements, ownerScreen, recordCarry, commonLawCarries, searchedJurisdictions = null }) {
+export function runLint({ depth, commonLawGrid, matterContext, clientPartyName, reportMd, clientSummaryMd, narrativeMd, auditMd, recordsByUri, searchedNames, headerName, ratedNames, actionsText, fetchFailures, extraPlatformNames, findings, narrativeFindings = null, findingsRaw, actionsRegister, actionsExpected, intakeAsks, askAnswers, cardFolds, verdictDoc, manifest, seniorRights, seniorRightsExpected, markAssessment, markAssessmentExpected, fourAnswers, contentModelExpected, findingsSchemaVersion, placements, ownerScreen, recordCarry, commonLawCarries, searchedJurisdictions = null }) {
   // WS-B: the run's profile platforms join the vocabulary for this run. Profiles carry store
   // DOMAINS by contract, so derive the name tokens a report would actually print: the raw norm
   // ("thomasnetcom"), the separator-spaced phrase ("thomasnet com" / "made in china com"), and the
@@ -2290,7 +2286,9 @@ export function runLint({ depth, commonLawGrid, matterContext, clientPartyName,
   if (clientSummaryMd) checks.push(...permissionProseChecks({ text: clientSummaryMd, surface: "client-summary", idSuffix: ":client" }));
   if (narrativeMd) checks.push(...permissionProseChecks({ text: narrativeMd, surface: "narrative", idSuffix: ":narrative", structural: true }));
   // — the narrative's own depth rules, on the narrative surface so they route to the synthesis redo.
-  if (narrativeMd) checks.push(...narrativeWriteUpChecks({ narrativeMd, findings, depth, manifest }));
+  // Its finding headings are in the model's numbering, so they join the record the model wrote when the
+  // delivered record is folded (`narrativeFindings`), and the delivered record otherwise.
+  if (narrativeMd) checks.push(...narrativeWriteUpChecks({ narrativeMd, findings: narrativeFindings ?? findings, depth, manifest }));
   // — the same rule on both surfaces the client's words come from. The narrative is where the
   // shipped defect was authored; the report is what a client reads, and a repair to one that left the
   // other standing is how this family's previous cures kept being re-applied by hand.
@@ -2669,6 +2667,8 @@ const DELIVERY_LINES = {
   // The sentence states the CONSEQUENCE, in the receipt's own terms: not "a check failed" but "the rule
   // was applied to nothing". Eleven graded runs delivered carrying this, two of them orderable product
   // demos, and the only place it was written was one row of a fifty-odd-row receipt nobody routes.
+  // No new run emits it now (a sectional narrative is a passing row that says the rule does not apply);
+  // the line stays so a republished receipt from before reads as it did.
   "narrative-write-ups:could-not-read":
     "The depth rules for the written-up findings were applied to nothing on this run — the narrative "
     + "carries no block this check can read, so neither the ranking cut nor the length cap was verified.",

package/driver/publish/index.mjs

@@ -598,7 +598,7 @@ export async function regenSurfaces(poolRoot) {}
  * rather than discovered later.
  *
  * WHAT THIS DOES NOT REACH, so the next reader does not assume it does:
- *   · the run's PROSE. `- Source: [EUIPO · 018575624](https://euipo.europa.eu/…)` is markdown the synthesis
+ *   · the run's PROSE. `- Source: [EUIPO · 099999992](https://euipo.europa.eu/…)` is markdown the synthesis
  *     wrote and renderProse links it like any other markdown. No field distinguishes a prose register
  *     citation from a prose evidence citation, so the only way to catch it is to pattern-match the URL —
  *     which is the move that produced this defect class in the first place.

package/driver/publish/knockout.mjs

@@ -15,7 +15,7 @@ import { riskTier, TONE_TIER, regenIndex, regenSurfaces, auditRouteFor, markRepo
 import { runKnockoutLint, deliveryFlagLines } from '../predelivery-lint.mjs';
 import { note } from '../log.mjs';
 import { addSheet } from './xlsx.mjs';
-import { COUNT_PREDICATES, COUNT_BASIS, countsForMark, countLine, countedMarks, variantFormsLine, disclosedFloor, moreThan } from '../register-count.mjs';
+import { COUNT_PREDICATES, COUNT_BASIS, countsForMark, countLine, countedMarks, variantFormsLine, disclosedFloor, moreThan, countNote } from '../register-count.mjs';
 import { RECORD_BASIS, recordsForMark, recordsLine, listedMarks, normalizeRegisterRecordLinks } from '../register-records.mjs';
 import { reportIdentityFor, productCoverageNote, kebab } from '../search-policy.mjs';
 import { batchMarkName } from '../mark-name.mjs';
@@ -235,10 +235,11 @@ export async function buildKnockoutWorkbook(findings, receipts, outPath, registe
       row['Close variation forms'] = variantFormsLine(e) ?? 'not recorded — this run predates the close-variation column';
       row['Register'] = registerCounts.providerLabel ?? registerCounts.provider ?? '';
       row['Basis'] = COUNT_BASIS;
-      // The verbatim provider reason for anything missing — the auditable half of "not available".
+      // The reader's line for anything missing. The provider's own reason, or an exception's message, stays
+      // in the counts record where it was written (register-count.mjs, countNote).
       row['Notes'] = COUNT_PREDICATES
         .filter((p) => !Number.isFinite(e?.counts?.[p.key]?.total) && disclosedFloor(e?.counts?.[p.key]) === null)
-        .map((p) => `${p.label}: ${e?.counts?.[p.key]?.unavailable ?? 'no count recorded'}`)
+        .map((p) => `${p.label}: ${countNote(e?.counts?.[p.key]) ?? 'no count recorded'}`)
         .join(' · ');
       return row;
     });
@@ -369,7 +370,7 @@ export function composeKnockoutEmail({ findings, framework, overall, reports = [
   // says how to read the list instead: a "full report" link on a batch could only be one name standing
   // for all of them. A single-mark run keeps its head link exactly as before — same bytes, same place.
   const only = n === 1 ? urlByMark.get((findings.marks ?? [])[0]?.name) ?? null : null;
-  const head = `<p style="${FONT}">Knockout trademark review${job?.ref ? ` — ${esc(job.ref)}` : ''}: <b>${n} mark${n === 1 ? '' : 's'}</b>, worst band <b style="color:${t.txt}">${esc(overall ?? '')}</b>.`
+  const head = `<p style="${FONT}">Knockout trademark review${job?.ref ? ` — ${esc(job.ref)}` : ''}: <b>${n} mark${n === 1 ? '' : 's'}</b>, ${n === 1 ? 'rating' : 'highest rating'} <b style="color:${t.txt}">${esc(overall ?? '')}</b>.`
     + (only ? ` <a href="${esc(only)}">Open the full report</a>${auditUrl ? ` · <a href="${esc(auditUrl)}">audit workbook</a>` : ''}.` : '')
     + (!only && n > 1 ? ` One report per name below${auditUrl ? `, and one <a href="${esc(auditUrl)}">audit workbook</a> for the batch` : ''}.` : '') + `</p>`;
   // — THE FIRST NON-BLANK, never element 0. `?? fallback` catches null and undefined

package/driver/publish/office-record-links.mjs

@@ -122,10 +122,25 @@ export function officeRecordLink(rec, uri = "") {
   const page = OFFICE_RECORD_PAGES[office];
   const own = designation ? clean(rec.irNumber) : clean(rec.applicationNumber) || clean(rec.registrationNumber);
   const unlinked = (reason) => ({ office, label: labelOf(office, own), href: null, reason });
+  const a = page?.address ? (designation ? madridMonitor([rec.irNumber]) : page.address(rec)) : null;
+  if (a) return { office, label: labelOf(office, a.number), href: a.href, reason: null };
+  // THE REGISTER'S OWN LINK, ONLY WHERE THE TABLE GIVES NONE. Some registers hand over the office's page
+  // for a record (`officeUrl`). The table above stays first: each of its addresses was checked against a
+  // real record, and on the records measured the register's link pointed at the same office's site in a
+  // different form, or at the designated office's page where the table opens the international
+  // registration. So the register's link fills only a gap — an office with no address here, or a number
+  // the address cannot take — and never replaces an address the table builds. Only an https address, and
+  // only beside a number the reader can be shown.
+  const given = registerGivenUrl(rec.officeUrl);
+  if (given && own) return { office, label: labelOf(office, own), href: given, reason: null };
   if (!page) return unlinked("unknown-office");
   if (!page.address) return unlinked("no-page");
-  const a = designation ? madridMonitor([rec.irNumber]) : page.address(rec);
-  return a ? { office, label: labelOf(office, a.number), href: a.href, reason: null } : unlinked("unaddressable");
+  return unlinked("unaddressable");
+}
+
+function registerGivenUrl(v) {
+  if (typeof v !== "string") return null;
+  try { return new URL(v).protocol === "https:" ? v : null; } catch { return null; }
 }
 
 /**

package/driver/publish/publish-inputs.mjs

@@ -133,7 +133,7 @@ export const CALLER_SUPPLIED = {
  * publish/index.mjs's source — reading a 1472-line sibling on every import to answer a question that
  * only changes when someone edits the file is the wrong place for it; the dead-key/undeclared-store
  * half runs in publish-input-coverage.test.mjs against the real source, on the
- * dependency-repair.test.mjs:76-95 precedent.
+ * dependency-repair.test.mjs precedent (its 15a and 15b tests).
  *
  * `tables` is injectable so the gate can be exercised against a partition nobody shipped, which is
  * otherwise unreachable from a test.

package/driver/publish/render-knockout.mjs

@@ -51,7 +51,7 @@ import { SUMMARY_BLOCK_LINE, parseSummaryBlocks } from '../../shared/summary-blo
 const STRIP = Object.freeze([
   ['summary', 'Summary'], ['findings', 'Findings'], ['filings', 'Also considered'], ['next', 'Next steps'],
 ]);
-import { COUNT_BASIS, COUNT_PREDICATES, countsForMark, countLine, variantFormsLine, disclosedFloor, moreThan } from '../register-count.mjs';
+import { COUNT_BASIS, COUNT_PREDICATES, countsForMark, countLine, variantFormsLine, disclosedFloor, moreThan, countNote } from '../register-count.mjs';
 import { RECORD_BASIS, recordsForMark, recordsLine } from '../register-records.mjs';
 import { officeLinkSentences } from './office-record-links.mjs';
 import { knockoutFindingViews, splitKnockoutNotes } from '../findings-model.mjs';
@@ -66,6 +66,7 @@ import { makeClassifyStatus, isAllClass } from '../../providers/_shared/screen.m
 import { saysSomethingNew } from '../../shared/says-something-new.mjs';
 import { isNextStepHeading } from '../knockout-next-step.mjs';
 import OFFERED from '../../shared/offered-territories.json' with { type: 'json' };   // the order form's own territory names
+import { normalizeTerritory } from '../../providers/_shared/territory-codes.mjs';   // a territory as written → its code
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -492,6 +493,17 @@ const orderedTerritoryName = (code) => {
   return ORDER_FORM_NAMES.get(c === 'EM' ? 'EU' : c) ?? '';
 };
 
+/**
+ * A territory as the order wrote it, as a code. An order carries a code ("EU", "UK") or a country's name
+ * ("Norway"), and both name lookups on this page take codes: a name reached them unconverted, came back
+ * empty and left the page without a trace (a delivered knockout, 2026-10-08, named two of the four
+ * territories it searched). The shared normaliser turns a name into its code; UK is the order form's GB.
+ */
+const orderCode = (t) => {
+  const c = normalizeTerritory(t) || String(t ?? '').trim().toUpperCase();
+  return c === 'UK' ? 'GB' : c;
+};
+
 /** "a, b and c" — the reader's list, not a join on commas. */
 function listWords(items) {
   const xs = (items ?? []).filter(Boolean);
@@ -561,7 +573,7 @@ function countsSection(marks, registerCounts, positions = '') {
       // archived run re-rendering through today's renderer has no close-variation cell because the
       // column did not exist when it was counted, and "no count recorded" would read as a defect in a
       // report that has none. The hover says which.
-      const why = c?.unavailable ?? (c
+      const why = countNote(c) ?? (c
         ? 'no count recorded'
         : 'not counted on this run — it predates this column, and an archived report re-renders as what it was');
       if (Number.isFinite(c?.total)) return `<td class="num">${esc(String(c.total))}</td>`;
@@ -1252,7 +1264,7 @@ function ownerCheckFor(ownerChecks, recordId) {
 function aboutRequestBlock(scope, requestNotes, depthNote = '', productContext = '', searched = '', registerCounts = null) {
   const goods = String(scope?.goods ?? '').trim();
   const classes = (Array.isArray(scope?.classes) ? scope.classes : []).filter((c) => c || c === 0);
-  const jx = (Array.isArray(scope?.jurisdictions) ? scope.jurisdictions : []).map((t) => territoryName(t)).filter(Boolean);
+  const jx = (Array.isArray(scope?.jurisdictions) ? scope.jurisdictions : []).map((t) => territoryName(orderCode(t))).filter(Boolean);
   const asked = goods;
   const classLine = classes.length ? classes.join(', ') : '';
   const where = jx.length ? listWords(jx) : '';
@@ -1279,9 +1291,9 @@ function aboutRequestBlock(scope, requestNotes, depthNote = '', productContext =
   // a territory nothing was counted in.
   const on = provider ? `, on ${provider}` : '';
   const sc = registerCounts?.scope ?? {};
-  const deferred = new Set((sc.deferredJurisdictions ?? []).map((c) => String(c ?? '').trim().toUpperCase()));
+  const deferred = new Set((sc.deferredJurisdictions ?? []).map(orderCode));
   const ordered = [...new Set((sc.jurisdictions ?? [])
-    .filter((c) => !deferred.has(String(c ?? '').trim().toUpperCase())).map(orderedTerritoryName))];
+    .filter((c) => !deferred.has(orderCode(c))).map((c) => orderedTerritoryName(orderCode(c))))];
   const namesTheOrder = sc.worldwide !== true && !(sc.unreachableOffices ?? []).length
     && ordered.length > 0 && ordered.every(Boolean);
   const counted = namesTheOrder ? `${listWords(ordered)}${on}.`

package/driver/publish/render.mjs

@@ -1705,9 +1705,11 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   // 404-card caveat (2026-07-22) — a cited record the V4-2 closure fetch DEFINITIVELY could not
   // retrieve (joinEvidenceStatus stamped `_recordFetchFailure` from the persisted failure list). ONE
   // deterministic code-owned line on the card, client render included: the reader must never take this
-  // card's registry values as record-verified. Absent stamp (no join ran / archived runs) ⇒ nothing.
+  // card's registry values as record-verified. Absent stamp (no join ran / archived runs) ⇒ nothing. The
+  // failure's cause is the record's (the persisted failure list and the stamp keep it), never the card's:
+  // it can be an exception's message.
   const fetchFailLine = f._recordFetchFailure
-    ? `<li class="openitem"><b>Official register record could not be retrieved (${esc(f._recordFetchFailure.cause || 'fetch failed')})</b> — registry details in this card are unverified.</li>`
+    ? `<li class="openitem"><b>Official register record could not be retrieved</b> — registry details in this card are unverified.</li>`
     : '';
   const regs = (f.owner?.registrations || []).map(r => {
     const uri = String(r.uri || '').toLowerCase();

package/driver/record-fold.mjs

@@ -0,0 +1,177 @@
+// 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
+//
+// THE FOLDED RECORD IS THE RECORD FROM THE DELIVERY SEAM ON (design, 2026-10-03).
+//
+// Before the overview and the cards are built, the driver folds a second filing of the same conflict into
+// one finding and renumbers the rest. A synthesis save after that seam — the pre-delivery lint's narrative
+// repair, the stale repair, the fix pass — wrote the model's own record back over the folded one, and
+// nothing folded it again. Measured on a test run: the folded filing stood as its own finding again, every
+// finding after it moved down one place, 19 cards were rebuilt for findings that had only moved, and the
+// last finding shipped without the prose card it was owed, because no card had ever been built at its
+// ordinal.
+//
+// So once the seam is passed, every accepted save folds again on acceptance, and findings.json — what the
+// reviewer after the seam, the cards and the delivery read — is always the folded record. Two things stay
+// in the model's numbering, because the model wrote them in it: its own record, which stays the base for
+// its patches (the call records the save keeps), and whatever is named against that record — a flag's
+// ordinals, the ordinals a save records it touched, the narrative's finding headings. So the record the
+// save wrote is kept beside the folded file while a fold is in force, with the fold's map both ways, and a
+// reader that joins something in the model's numbering reads that record (`modelRecordPath`).
+//
+// THE STATE, in _driver/fold.json:
+//   seamPassed — this pass has passed the seam. A pass opens with it cleared (`openPass`) and the seam's
+//                own fold sets it, so a save before the seam on a resumed pass writes the model's record,
+//                as every save before the seam always has.
+//   map        — {modelToFolded, foldedToModel} for findings.json as it stands; null when the file is
+//                the record as the save wrote it.
+// and _driver/findings-unfolded.json — that record, in the model's numbering, kept only while a fold is
+// in force.
+import { readFileSync, writeFileSync, existsSync, renameSync, rmSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { driverDir } from "../shared/driver-dir.mjs";
+import { consolidateFindings, remapActionOrdinals, parseFindingsJson } from "./findings-model.mjs";
+import { parseFrameworkManifest } from "./framework.mjs";
+
+export const FOLD_FILE = "fold.json";
+export const UNFOLDED_FILE = "findings-unfolded.json";
+
+const bothWays = (ordinalMap) => {
+  const modelToFolded = {}, foldedToModel = {};
+  for (const [m, f] of ordinalMap) { modelToFolded[m] = f; (foldedToModel[f] ??= []).push(m); }
+  return { modelToFolded, foldedToModel };
+};
+
+/**
+ * Fold a findings document as the delivery seam does: a second filing of the same conflict folds into one
+ * finding, the findings renumber, and the actions follow the renumber. `map` is null when nothing folds,
+ * and the document is then returned as it came. PURE.
+ */
+export function foldRecord(doc, manifest = null) {
+  const list = Array.isArray(doc?.findings) ? doc.findings : [];
+  if (list.length < 2) return { doc, merges: [], map: null };
+  const { findings, merges, ordinalMap } = consolidateFindings(list, (doc.schema_version ?? 1) >= 4 ? manifest : null);
+  if (!merges.length) return { doc, merges: [], map: null };
+  const next = { ...doc, findings };
+  // spec 64 — a merged-away ordinal remaps to its kept finding's new ordinal
+  if (Array.isArray(doc.actions)) next.actions = remapActionOrdinals(doc.actions, ordinalMap);
+  return { doc: next, merges, map: bothWays(ordinalMap) };
+}
+
+/** The fold state of a run, or null before any seam. Never throws. */
+export function readFold(runDir) {
+  try { return JSON.parse(readFileSync(driverDir(String(runDir ?? ""), FOLD_FILE), "utf8")); } catch { return null; }
+}
+
+function writeFold(runDir, { seamPassed, map = null, merges = [], error = null }) {
+  const at = driverDir(String(runDir ?? ""), FOLD_FILE);
+  mkdirSync(dirname(at), { recursive: true });
+  const tmp = `${at}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({
+    _provenance: "the fold of findings.json as it stands: whether this pass has passed the delivery seam, and the map from the model's ordinals to the folded ones and back",
+    at: new Date().toISOString(), seamPassed: Boolean(seamPassed), map,
+    // ordinals only: the names stay in the record itself
+    merges: (merges ?? []).map((m) => ({ kept: m.kept, dropped: m.dropped })),
+    ...(error ? { error } : {}),
+  }, null, 2) + "\n");
+  renameSync(tmp, at);
+}
+
+function writeAtomic(file, text) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+}
+
+/**
+ * Fold findings.json in place and record the fold. The seam calls it with `seam: true`; every accepted save
+ * calls it after writing the record, and it folds only once this pass has passed the seam. Before the seam
+ * the save wrote the model's record as it always has, and the state then says the file is unfolded.
+ *
+ * Returns `{merges}`, empty when nothing folded, and `error` when a fold could not be made. Never throws: a
+ * record that cannot be folded stays as the save wrote it, which is what every run did before this.
+ */
+export function foldFindingsFile(runDir, findingsPath, manifest, { seam = false } = {}) {
+  const dir = String(runDir ?? "");
+  const state = readFold(dir);
+  const unfoldedAt = driverDir(dir, UNFOLDED_FILE);
+  let folded = null;   // the fold, once findings.json holds it
+  try {
+    if (!seam && state?.seamPassed !== true) {
+      if (state?.map) { writeFold(dir, { seamPassed: false }); rmSync(unfoldedAt, { force: true }); }
+      return { merges: [] };
+    }
+    if (!existsSync(findingsPath)) { writeFold(dir, { seamPassed: true }); return { merges: [] }; }
+    const raw = readFileSync(findingsPath, "utf8");
+    const { doc, merges, map } = foldRecord(JSON.parse(raw), manifest);
+    if (!merges.length) {
+      // Nothing folds. On a resumed pass the file can be the earlier pass's fold with no save since: the
+      // record and the map it was folded by both stand.
+      const held = seam && state?.map && existsSync(unfoldedAt);
+      writeFold(dir, held ? { seamPassed: true, map: state.map, merges: state.merges } : { seamPassed: true });
+      if (!held) rmSync(unfoldedAt, { force: true });
+      return { merges: [] };
+    }
+    parseFindingsJson(JSON.stringify(doc));   // the folded record must still validate; a throw keeps the record as written
+    writeAtomic(unfoldedAt, raw);
+    writeAtomic(findingsPath, `${JSON.stringify(doc, null, 2)}\n`);
+    folded = { map, merges };
+    writeFold(dir, { seamPassed: true, map, merges });
+    return { merges };
+  } catch (e) {
+    // A fold that cannot be made leaves the record as the save wrote it, and the state must say so: a map
+    // and a kept record from an earlier fold would send every reader of the model's numbering to a record
+    // this save has replaced. The failure is recorded, because nothing else reads this function's return.
+    const error = String(e?.message ?? e).replace(/\s+/g, " ").slice(0, 160);
+    try {
+      const seamPassed = seam || state?.seamPassed === true;
+      if (folded) writeFold(dir, { seamPassed, ...folded, error });
+      else { rmSync(unfoldedAt, { force: true }); writeFold(dir, { seamPassed, error }); }
+    } catch { /* best-effort */ }
+    return { merges: [], error };
+  }
+}
+
+/** The fold an accepted save makes, with the run's frozen framework manifest. Never throws. */
+export function foldAfterSave(runDir, findingsPath) {
+  let manifest = null;
+  try { manifest = parseFrameworkManifest(readFileSync(driverDir(String(runDir ?? ""), "framework.json"), "utf8")); }
+  catch { manifest = null; }   // a run with no frozen manifest folds as the seam does for it
+  return foldFindingsFile(runDir, findingsPath, manifest);
+}
+
+/** A pass opens before the seam. The map stands: the file on disk is still what the last writer left. */
+export function openPass(runDir) {
+  const state = readFold(runDir);
+  if (!state?.seamPassed) return;
+  try { writeFold(runDir, { ...state, seamPassed: false }); } catch { /* best-effort: the seam rewrites it */ }
+}
+
+/** The record in the model's numbering: the one the last save wrote while a fold is in force, else findings.json. */
+export function modelRecordPath(runDir, findingsPath) {
+  const at = driverDir(String(runDir ?? ""), UNFOLDED_FILE);
+  return readFold(runDir)?.map && existsSync(at) ? at : findingsPath;
+}
+
+/** The fold as it stands, to put back if a pass that changed it is rolled back. Never throws. */
+export function snapshotFold(runDir) {
+  const state = readFold(runDir);
+  let unfolded = null;
+  try { if (state?.map) unfolded = readFileSync(driverDir(String(runDir ?? ""), UNFOLDED_FILE), "utf8"); } catch { unfolded = null; }
+  return { state, unfolded };
+}
+
+/** Put a snapshot's fold back beside the findings.json it described. This pass's seam stays as it is. */
+export function restoreFold(runDir, snap) {
+  const dir = String(runDir ?? "");
+  try {
+    const seamPassed = readFold(dir)?.seamPassed === true;
+    if (snap?.state?.map && snap.unfolded != null) {
+      writeAtomic(driverDir(dir, UNFOLDED_FILE), snap.unfolded);
+      writeFold(dir, { seamPassed, map: snap.state.map, merges: snap.state.merges });
+    } else {
+      rmSync(driverDir(dir, UNFOLDED_FILE), { force: true });
+      if (readFold(dir)) writeFold(dir, { seamPassed });
+    }
+  } catch { /* best-effort: the next save or seam rewrites the state */ }
+}

package/driver/register-count.mjs

@@ -95,7 +95,7 @@ import { resolveRegions } from "./register-plan.mjs";
 import { reachableRegions } from "./register-availability.mjs";   // — pure; the env binding is injected
 import { variantForms, VARIANT_RULES, VARIANT_CAP } from "./register-variants.mjs";
 import { isCapabilityGap } from "../providers/_shared/execute-plan.mjs";
-import { plainDeferralReason } from "./deferral-row.mjs";   // — the reader's line for a count left open
+import { plainDeferralReason, plainCause } from "./deferral-row.mjs";   // — the reader's line for a count left open
 
 /** The three questions, in report order. `matchMode` is the provider-neutral predicate name.
  *
@@ -594,6 +594,23 @@ export function disclosedFloor(c) {
 /** A floor as every page prints it: the register's own figure, and no sentence around it. */
 export const moreThan = (floor) => `more than ${floor.toLocaleString("en-US")}`;
 
+/**
+ * THE READER'S LINE FOR A COUNT THAT DID NOT LAND. A count's `unavailable` text is the counts record's: it
+ * can carry the provider's own refusal, or an exception's message (`count threw: …`), and that text
+ * belongs to the record, never to a cell a client reads. Two lines the counter writes for a reader stay as
+ * they are: a name with no near-form, and how many of the close-variation forms went uncounted (without the
+ * raw causes that follow it). Anything else reads as the shipped line for a count left open
+ * (deferral-row.mjs, plainCause). `null` when the cell has no text. PURE.
+ */
+export function countNote(cell) {
+  const t = String(cell?.unavailable ?? "").trim();
+  if (!t) return null;
+  if (/^no close-variation forms could be generated from ".*" — the name has no near-form under any rule in the table, so there was nothing to count$/.test(t)) return t;
+  const partial = /^\d+ of \d+ variant form\(s\) could not be counted, so the total would understate(?= — |$)/.exec(t);
+  if (partial) return partial[0];
+  return plainCause(t);
+}
+
 export function countLine(entry) {
   if (!entry?.counts) return null;
   const parts = COUNT_PREDICATES.map((p) => {