clearotron 0.4.0 → 0.4.1-beta.1

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

@@ -121,8 +121,8 @@ export const NOT_READ_BY_NAME = {
 // absent one is the caller's error and already throws. Declared so the source scan can tell "argument"
 // from "undeclared store" instead of demanding a gating for something that has none.
 export const CALLER_SUPPLIED = {
-  "report.md": "the reportMd ARGUMENT — read unconditionally at index.mjs:653; an unreadable one throws, which is correct (there is no report to publish)",
-  "audit.md": "the auditMd ARGUMENT — existence-gated at index.mjs:942-943; a run with no audit markdown legitimately publishes without a workbook",
+  "report.md": "the reportMd ARGUMENT — read unconditionally by publishReport() in index.mjs; an unreadable one throws, which is correct (there is no report to publish)",
+  "audit.md": "the auditMd ARGUMENT — existence-gated in publishReport() in index.mjs; a run with no audit markdown legitimately publishes without a workbook",
 };
 
 /**
@@ -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/publish/xlsx.mjs

@@ -574,7 +574,7 @@ function coverageJudgmentSummaryRows(cj) {
   const rows = Array.isArray(cj?.rows) ? cj.rows : [];
   if (!rows.length) return [];
   return [{ Field: '', Value: '' }, { Field: 'Coverage judgment — slices considered', Value: '', _head: true },
-    ...rows.map((r) => ({ Field: `   ${plainNote(r.area)}`, Value: plainNote(r.note) }))];
+    ...rows.map((r) => ({ Field: `   ${plainNote(r.areaLabel || r.area)}`, Value: plainNote(r.note) }))];
 }
 function correctionsSummaryRows(c) {
   const entries = Array.isArray(c?.entries) ? c.entries : [];

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

@@ -90,12 +90,12 @@
 import { existsSync, readFileSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { kebab } from "./search-policy.mjs";
+import { kebab } from "./search-policy.mjs"; import { moreThan } from "../shared/register-floor.mjs";
 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.
  *
@@ -592,7 +592,24 @@ 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")}`;
+export { moreThan } from "../shared/register-floor.mjs";
+
+/**
+ * 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;

package/driver/register-coverage.mjs

@@ -32,7 +32,7 @@
 // ── AND WHY IT DELEGATES TO resolveRegions RATHER THAN RE-IMPLEMENTING IT ───────────────────────────
 //
 // Five vocabularies sit between a display name and a covered office: display → `normalizeTerritory` →
-// `canonicalJurisdictionCode` → `offices.translate` → `covered.has`. `register-plan.mjs:206-216` records
+// `canonicalJurisdictionCode` → `offices.translate` → `covered.has`. resolveRegions() in register-plan.mjs records
 // the copper-bastion incident from re-implementing that chain — the composer submitted display names,
 // corsearch's ISO-passthrough translate sent them to the wire verbatim, the vendor answered 500 rather
 // than 400, and recovery burned its park budget re-sending a query that could never succeed.

package/driver/register-plan.mjs

@@ -366,6 +366,20 @@ export const planMaxOrWidth = (capabilities) =>
   Number.isFinite(capabilities?.maxOrWidth) && capabilities.maxOrWidth >= 1
     ? Math.floor(capabilities.maxOrWidth) : PLAN_MAX_OR_WIDTH;
 
+/**
+ * The OR-stack width for an EXACT spelling band. A provider whose general width is narrower than what it
+ * can take for exact spellings declares `exactOrWidth` (signa: one term per request in general, up to 100
+ * exact spellings as one ranked list); every other provider stacks exact spellings at its general width.
+ */
+export const planExactOrWidth = (capabilities) =>
+  Number.isFinite(capabilities?.exactOrWidth) && capabilities.exactOrWidth >= 1
+    ? Math.floor(capabilities.exactOrWidth) : planMaxOrWidth(capabilities);
+
+/** The OR-stack width for a SOUND-ALIKE band, by the same rule: `phoneticOrWidth` where a provider declares one. */
+export const planPhoneticOrWidth = (capabilities) =>
+  Number.isFinite(capabilities?.phoneticOrWidth) && capabilities.phoneticOrWidth >= 1
+    ? Math.floor(capabilities.phoneticOrWidth) : planMaxOrWidth(capabilities);
+
 // The plan emits ONE `wildcard` predicate; the provider contract splits it into three sub-capabilities.
 // Mirrors the executor's planPredicateParams anchoring exactly (trailing * → prefix/starts-with,
 // leading * → suffix/ends-with, both/neither → infix over the raw pattern).
@@ -1111,26 +1125,31 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
   //     anywhere: the exact silent-wrong-query false-clean class this carriage fix exists to kill,
   //     quieter than the loud deferral it replaced. formKey now strips accents from LATIN bases only
   //     and preserves every non-Latin combining mark (width still folds via NFKD).
-  //   - and if two variants STILL share a key while dictating different romanisations (the model
-  //     contradicting itself about one term), the key is poisoned rather than resolved by position:
-  //     those entries compile BARE, and the romanisation-index provider's refusal turns the
-  //     contradiction into a loud disclosed deferral — never into whichever answer came first.
+  //   - and two variants that share a key while dictating DIFFERENT romanisations carry EVERY one of
+  //     them, on every entry for that key. One string of characters can have two readings: the same
+  //     Han characters are read one way in Chinese and another in Japanese, and the manifest lists the
+  //     string once per reading. This rule used to read that as the model contradicting itself and
+  //     compile the key bare, so the romanisation-index provider refused it and the slice reached the
+  //     client as "not searched" — while the model, seeing the refusal, searched both readings as
+  //     supplementals and got its answer (a delivered report, 2026-10-08). Carrying every reading still never
+  //     resolves by position, and never sends a sibling's form in place of the dictated one: each
+  //     reading is asked, in the same request, and a reading that is simply wrong costs one spelling.
   const romanByValue = new Map();
   for (const v of manifest.variants) {
     if (!v.romanization) continue;
     const key = formKey(v.value);
-    const prior = romanByValue.get(key);
-    if (prior === undefined) romanByValue.set(key, v.romanization);
-    else if (prior !== null && romanizationSpellings(prior)[0] !== romanizationSpellings(v.romanization)[0])
-      romanByValue.set(key, null);   // conflicting dictates ⇒ stamp NOTHING for this key (loud backstop)
+    const readings = romanByValue.get(key) ?? [];
+    const reading = romanizationSpellings(v.romanization)[0];
+    if (reading && !readings.some((r) => romanizationSpellings(r)[0].toUpperCase() === reading.toUpperCase()))
+      readings.push(v.romanization);
+    romanByValue.set(key, readings);
   }
   const romanStamp = (e) => {
     // An owner NAME is not mark text and rides its own field (the executor drops the carrier on an
     // owner query anyway). An OR-stack is chunked, not substituted — one non-Latin member must never
     // silently replace a whole chunk's names, so a `terms[]` entry never carries the field.
     if (e.predicate === "owner" || Array.isArray(e.terms)) return {};
-    const roman = romanByValue.get(formKey(e.term));
-    const spellings = roman ? romanizationSpellings(roman) : [];
+    const spellings = [...new Set((romanByValue.get(formKey(e.term)) ?? []).flatMap(romanizationSpellings))];
     return spellings.length ? { romanizedTerms: spellings } : {};
   };
 
@@ -1266,7 +1285,7 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
   // this compiler's own equivalence: `norm` and `formKey` both strip separators, so "BIO VELTRIS",
   // "BIOVELTRIS", "BIO-VELTRIS" and "BIO.VELTRIS" are ONE key. The variant loop below already drops a
   // model variant that restates the mark that way, on exactly that test. Dispatching the generated set
-  // would send the mark's own exact entry three more times under a different spelling — the PARADISE
+  // would send the mark's own exact entry three more times under a different spelling — the Drivers Haven
   // shape (five diacritic terms, same 424 hits, the run's record budget gone), re-imported. The family
   // is enumerated and marked in form-neighbourhood.json because it is genuinely mechanical and the
   // surfaces that do NOT fold spacing are real; wiring it to those is not this change.
@@ -1472,8 +1491,11 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
     const formTerms = [...formBand.exactQueries];
     const latinFormTerms = formTerms.filter((t) => !isNonLatinTerm(t));
     const nativeFormTerms = formTerms.filter((t) => isNonLatinTerm(t));
-    for (let i = 0; i < latinFormTerms.length; i += maxOrWidth)
-      push({ axis: "primary-sweep", predicate: "exact", terms: latinFormTerms.slice(i, i + maxOrWidth), expected_kind: "enumerate", provenance: "floor", qidSuffix: "+form" });
+    // An exact band stacks at the provider's EXACT width, which is wider than its general one where the
+    // register takes a list of exact spellings in one request (planExactOrWidth).
+    const exactWidth = planExactOrWidth(caps);
+    for (let i = 0; i < latinFormTerms.length; i += exactWidth)
+      push({ axis: "primary-sweep", predicate: "exact", terms: latinFormTerms.slice(i, i + exactWidth), expected_kind: "enumerate", provenance: "floor", qidSuffix: "+form" });
     for (const t of nativeFormTerms)
       push({ axis: "primary-sweep", predicate: "exact", term: t, expected_kind: "enumerate", provenance: "floor", qidSuffix: "+form" });
   }
@@ -2173,7 +2195,10 @@ export function validatePlanFeasibility(plan, { capabilities = null, maxOrWidth
     if (!PLAN_PREDICATES.includes(e?.predicate)) add("unexecutable", `unknown predicate "${e?.predicate}"`);
     const names = Array.isArray(e?.terms) ? e.terms : e?.term != null ? [e.term] : [];
     if (!names.length || names.some((t) => !String(t ?? "").trim())) add("unexecutable", "empty term(s)");
-    if (Array.isArray(e?.terms) && e.terms.length > maxOrWidth) add("repairable", `OR-stack of ${e.terms.length} names exceeds the executor bound (${maxOrWidth}) — the executor runs it chunked`);
+    const width = !capabilities ? maxOrWidth
+      : e?.predicate === "exact" ? Math.max(maxOrWidth, planExactOrWidth(capabilities))
+        : e?.predicate === "phonetic" ? Math.max(maxOrWidth, planPhoneticOrWidth(capabilities)) : maxOrWidth;
+    if (Array.isArray(e?.terms) && e.terms.length > width) add("repairable", `OR-stack of ${e.terms.length} names exceeds the executor bound (${width}) — the executor runs it chunked`);
     for (const t of names) if (String(t).length > maxNameLength) add("repairable", `name exceeds ${maxNameLength} chars ("${String(t).slice(0, 40)}…") — provider-side truncation risk only`);
     if ((e?.nice_classes ?? []).some((c) => !Number.isFinite(Number(c)))) add("unexecutable", "non-numeric nice_class");
     if (e?.when && guardParentQid(e.when) != null && !qids.has(guardParentQid(e.when))) add("unexecutable", `when-guard targets unknown qid "${guardParentQid(e.when)}"`);
@@ -2359,7 +2384,10 @@ export function joinPlanToBands(plan, bandBlocksByAxis, { released = new Set() }
         // and the report's coverage line claims to: it reads "skipped after a broader search came back
         // crowded", which is true when the parent was `incomplete` and false when the parent FAILED or
         // never ran. The state that decides it is read one line above and was thrown away here.
-        if (parentState !== "enumerated") { skipped.push({ qid: e.qid, guard: e.when.runs_if_enumerated, parent_state: parentState || null }); continue; }
+        // AND WHETHER IT ERRED, because the state cannot say: a band has two states, and the executor writes
+        // every provider error as `incomplete` with `error: true` beside it. Read off the state alone, a
+        // broader search that failed was a broader search that crowded.
+        if (parentState !== "enumerated") { skipped.push({ qid: e.qid, guard: e.when.runs_if_enumerated, parent_state: parentState || null, ...(parent?.error === true ? { parent_error: true } : {}) }); continue; }
       }
     }
     const b = byQid.get(e.qid);
@@ -2404,6 +2432,16 @@ export function joinPlanToBands(plan, bandBlocksByAxis, { released = new Set() }
       state: String(b.state ?? "").toLowerCase(),
       records: recs,
       total_hits: Number.isFinite(hits) ? hits : null,
+      // A SLICE THAT RAN AND COULD NOT BE ANSWERED. The executor stamps `deferred: true` with no error on an
+      // owner sweep whose name the register never resolved: the call ran, so it is executed, and the band
+      // says `incomplete` with no count. The deferral is the only thing that tells it from a listing that
+      // overflowed, so it rides with the row rather than stopping at the block.
+      ...(b.deferred === true ? { deferred: true } : {}),
+      // WHAT THE TOTAL COUNTS, when the register said: `records`, one per country a mark covers. Every
+      // reader of this row reads the count as the register's own number (ruled 2026-10-02).
+      ...(typeof b.total_counts === "string" ? { total_counts: b.total_counts } : {}),
+      // The register's floor when it answered "at least N" instead of a count: total_hits stays null beside it.
+      ...(Number.isFinite(b.total_floor) ? { total_floor: b.total_floor } : {}),
     });
   }
   const planQids = new Set(plan.entries.map((e) => e.qid));
@@ -2613,9 +2651,30 @@ export function deriveCoverageSkeleton(plan, join) {
   const deferredQids = new Set((join.deferred ?? []).map((x) => x.qid));
   const awaitingQids = new Set((join.awaiting ?? []).map((x) => x.qid));
   const askedQids = new Set((join.asked ?? []).map((x) => x.qid));
+  // ── A COUNT THE PLAN ALSO READ IN FULL IS NOT A CROWD ──────────────────────────────────────────
+  // A count-only descriptor (the saturation probe's shape) sizes a question and reads none of its
+  // records, so it lands `incomplete` and its axis reads as a crowd. Where another entry asked the
+  // IDENTICAL question — predicate, term, classes, territories, owner and goods — and listed every
+  // record of the same total, nothing the count describes is unread. Leaving the axis `incomplete` told
+  // the reading seat a set was unreviewed that had been read in full, and a delivered report made its
+  // verdict conditional on reviewing it (2026-10-08). Anything short of that stays a crowd.
+  const entryByQid = new Map(plan.entries.map((e) => [e.qid, e]));
+  const question = (e) => (!e || Array.isArray(e.terms) ? null : JSON.stringify([
+    String(e.predicate ?? ""), formKey(String(e.term ?? "")),
+    [...(e.nice_classes ?? [])].map(String).sort(), [...(e.regions ?? [])].map(String).sort(),
+    String(e.owner ?? ""), goodsTermsList(e)]));
+  const readInFull = new Map();
+  for (const x of join.executed) {
+    if (x.state !== "enumerated" || !Number.isInteger(x.total_hits) || x.records !== x.total_hits) continue;
+    const q = question(entryByQid.get(x.qid));
+    if (q) readInFull.set(q, x.total_hits);
+  }
+  const totalByQid = new Map(join.executed.map((x) => [x.qid, x.total_hits]));
+  const readElsewhere = (e) => e.expected_kind === "count" && Number.isInteger(totalByQid.get(e.qid))
+    && readInFull.get(question(e)) === totalByQid.get(e.qid);
   const axes = new Map();
   for (const e of plan.entries) {
-    if (!axes.has(e.axis)) axes.set(e.axis, { axis: e.axis, entries: 0, executed: 0, crowds: 0, missing: [], skipped: 0, deferred: [], awaiting: 0, asked: 0 });
+    if (!axes.has(e.axis)) axes.set(e.axis, { axis: e.axis, entries: 0, executed: 0, crowds: 0, missing: [], skipped: 0, deferred: [], awaiting: 0, asked: 0, readElsewhere: 0 });
     const a = axes.get(e.axis);
     a.entries++;
     // COUNTED BEFORE `skipped`, and separately from it. With the families waiting on every matter this is the ordinary state of
@@ -2631,7 +2690,10 @@ export function deriveCoverageSkeleton(plan, join) {
     // a capability gap is NOT executed — it is a disclosed hole in the axis
     if (deferredQids.has(e.qid)) { a.deferred.push(e.qid); continue; }
     a.executed++;
-    if (stateByQid.get(e.qid) === "incomplete") a.crowds++;
+    if (stateByQid.get(e.qid) === "incomplete") {
+      if (readElsewhere(e)) a.readElsewhere++;
+      else a.crowds++;
+    }
   }
   return [...axes.values()].map((a) => ({
     axis: a.axis,
@@ -2655,6 +2717,7 @@ export function deriveCoverageSkeleton(plan, join) {
     entries: a.entries, executed: a.executed, crowds: a.crowds, skipped: a.skipped, missing: a.missing,
     ...(a.awaiting ? { awaiting: a.awaiting } : {}),
     ...(a.asked ? { asked: a.asked } : {}),
+    ...(a.readElsewhere ? { read_elsewhere: a.readElsewhere } : {}),
     ...(a.deferred.length ? { deferred: a.deferred } : {}),
   }));
 }
@@ -2777,8 +2840,10 @@ export function openBlocksByAxis(skeleton, bandBlocksByAxis, plan) {
       // under the deleted prose join (the qid, or this number standalone). Both are now written INTO the
       // form's row by the driver, so the equivalence the join had to test for is structural — see
       // coverage-form.mjs. The field stays because the row, the render and the failure token all carry it.
+      // A null total stays off the row: `Number(null)` is 0, which printed "(0 counted)" for a register's floor
+      // ("at least 10,000") and for a count the register refused to give.
       unverified.push({ qid: e.qid,
-        ...(Number.isInteger(Number(b.total_hits)) ? { total_hits: Number(b.total_hits) } : {}),
+        ...(b.total_hits != null && Number.isInteger(Number(b.total_hits)) ? { total_hits: Number(b.total_hits) } : {}),
         ...(unaccounted.length ? { unaccounted: unaccounted.slice(0, 8) } : {}),
         ...(unaccountedClasses.length ? { unaccounted_classes: unaccountedClasses.slice(0, 8) } : {}) });
     }

package/driver/register-records.mjs

@@ -149,6 +149,9 @@ function toRecord(row, { term, basis, provider }) {
     registrationNumber: row?.registration_number ?? null,
     irNumber: row?.ir_number ?? null,
     filingRoute: row?.filing_route ?? null,
+    // The office's page as the register gave it, where it gave one; publish uses it only when the numbers
+    // above do not address the office's page.
+    officeUrl: row?.office_url ?? null,
     // WHICH QUESTION FOUND IT. Without this a reader cannot tell a filing on the name from a filing on
     // a generated variant, and the two mean very different things to the person deciding on the name.
     matchedForm: term,
@@ -248,6 +251,7 @@ export async function listRegisterRecords({
             classes: scoped, regions, provider, ok, requested: want, fetched,
             total: Number.isFinite(r?.total) ? r.total : null, took_ms: Date.now() - started,
             ...(ok && r?.approximate === true ? { approximate: true, floor: Number.isFinite(r?.floor) ? r.floor : null } : {}),
+            ...(ok && Array.isArray(r?.warnings) && r.warnings.length ? { warnings: r.warnings } : {}),
             ...(ok ? {} : { cause: String(r?.reason ?? "unknown").slice(0, 300) }),
           }) + "\n");
         } catch { /* receipts are best-effort, never fatal */ }
@@ -260,6 +264,9 @@ export async function listRegisterRecords({
         // An approximation is carried as one, exactly as the count lane records it: no number in
         // `total`, the register's floor beside it. Only a provider whose listing states it sets it.
         ...(ok && r?.approximate === true ? { approximate: true, floor: Number.isFinite(r?.floor) ? r.floor : null } : {}),
+        // The register's own notes on this answer, as it sent them — absent when it sent none, which is
+        // not evidence that the answer carried no caveat on a register that sends none at all.
+        ...(ok && Array.isArray(r?.warnings) && r.warnings.length ? { warnings: r.warnings } : {}),
         ...(ok ? {} : { reason: String(r?.reason ?? "the filings could not be fetched").slice(0, 300) }),
       };
     });