clearotron 0.3.1 → 0.3.2-beta.1

package/driver/portal-families.mjs

@@ -9,7 +9,7 @@
 //
 // ── why this is a sidecar and not a field in meta.json ────────────────────────────────────────────────
 //
-// The same reason `archive-tags.json` is one, recorded at publish/index.mjs:338: "meta.json is rewritten
+// The same reason `archive-tags.json` is one, recorded at publish/index.mjs:377 ARCHIVE_TAGS_FILE: "meta.json is rewritten
 // on every republish so a flag there would be lost." That is not hypothetical here — a `rerender-all`
 // pass over the pool is a live plan, and a family written into meta would be erased by the very operation
 // meant to bring old reports up to date. Curation state that a person entered by hand must outlive a

package/driver/predelivery-lint.mjs

@@ -32,6 +32,7 @@ import { writeUpViolations, writeUpMessage } from "./narrative-write-ups.mjs";
 import { findRegistryArithmeticIssues, findRegistryViolations, splitBlocks } from "./registry-fidelity.mjs";
 import { CLIENT_TIER_BY_COMPOSITE, joinFindingToBlock, parseBlockOrd, worstLiveBand, NO_RATED_CONFLICTS, deriveActionConditions, isUnconditionalProceed, verdictStance, joinAskToAnswer, projectAssessmentField, POSITION_REQUIRED_DISPOSITIONS, OFF_FIELD_GROUNDS, FINDINGS_SCHEMA_VERSION, netChainMarkers, STATEMENT_CLAUSE_MAX } from "./findings-model.mjs";
 import { normalizeBand } from "./framework.mjs";
+import { clientConditions, ENGINE_TOKEN_RE } from "./terminal-clamp.mjs";   // the reader's clause per condition, and the token shape it may never carry
 import { knockoutNoteView, REQUEST_NOTE_WORDS, REQUEST_SUBJECT_WORDS } from "./findings-model.mjs";   // one reader for where a note prints
 import { isEngineAppendedCaveat } from "./verify-knockout.mjs";   // ONE derivation for "the engine appended this caveat, not a seat"
 
@@ -1961,6 +1962,26 @@ export function verdictActionsCoherenceChecks({ actionsRegister, findings, verdi
 // the conditional FORM riskStatement composes ("<Tier> — conditional on: <facts>"), never a wording
 // regex. Legacy sidecars (no stance) get the tier + unconditional-proceed checks only — judged
 // against the wording THEIR era composed (the retired-phrase exemption below), never the new form.
+// ── THE CONDITIONS A CLIENT READS SPEAK A LAWYER'S NOUNS ────────────────────────────────────────────
+// The sidecar carries two texts per condition — a run-record `reason` that may name tokens, counts and
+// record ids, and the reader's `clause`. `clientConditions` is the one reader of that pair, so this
+// check asks the question over what a surface actually renders rather than over either array.
+//
+// IT FIRES ON A LEGACY SIDECAR, DELIBERATELY. A run recorded before clauses were persisted has none, so
+// every condition falls back to its run-record reason and a token-bearing one flags here. That is the
+// honest reading: the delivered page for that run does carry the token, and re-generating the run is
+// what clears it. A flag, never a withholding — the report ships and the operator sees where the gap is.
+export function clientConditionVoiceChecks({ verdictDoc }) {
+  if (!verdictDoc) return [];
+  const carrying = clientConditions(verdictDoc)
+    .map((c) => ({ c, m: String(c).match(ENGINE_TOKEN_RE) }))
+    .filter((x) => x.m);
+  return [check("client-condition-voice", "verdict", "report", carrying.length === 0,
+    carrying.length
+      ? `${carrying.length} delivered condition${carrying.length === 1 ? "" : "s"} carr${carrying.length === 1 ? "ies" : "y"} an engine identifier, so the client's "conditional on:" list reads the run record rather than the reader's sentence: ${carrying.slice(0, 3).map((x) => `"${x.m[0]}"`).join(", ")}${carrying.length > 3 ? ` (+${carrying.length - 3} more)` : ""}. The clause exists at the clamp site; persist it and this list takes it. A sidecar written before clauses were persisted flags until the run is re-generated.`
+      : "")];
+}
+
 export function statementCoherenceChecks({ verdictDoc }) {
   if (!verdictDoc?.statement) return [];
   const st = String(verdictDoc.statement), tier = String(verdictDoc.tier ?? "");
@@ -2292,7 +2313,8 @@ export function runLint({ depth, commonLawGrid, matterContext, clientPartyName,
   if (findings && clientSummaryMd) checks.push(...clientTierChecks({ clientSummaryMd, findings, manifest }));   // A2 (doc 50: band words via the frozen manifest)
   if (verdictDoc?.tier && reportMd) checks.push(...overallTierChecks({ reportMd, verdictDoc }));         // wp50/wi2
   checks.push(...verdictActionsCoherenceChecks({ actionsRegister, findings, verdictDoc }));              // spec 64
-  checks.push(...statementCoherenceChecks({ verdictDoc }));                                              // spec 64
+  checks.push(...statementCoherenceChecks({ verdictDoc }));
+  checks.push(...clientConditionVoiceChecks({ verdictDoc }));                                         // — the reader's clause, not the run record                                              // spec 64
   checks.push(...conditionalTextCoherenceChecks({ reportMd, clientSummaryMd, verdictDoc }));             // qw/verdict-text-coherence — CONDITIONAL badge vs clean-outcome prose
   checks.push(...prescriptionProseChecks({ reportMd, clientSummaryMd, findings, fourAnswers }));         // PR-3 report voice — facts that condition, never advice; flag-only (P5: the findings-derived prose is a delivered surface too)
   checks.push(...onlyYouRegisterChecks({ actionsRegister, findings, reportMd }));                        // spec 64

package/driver/publish/index.mjs

@@ -16,6 +16,7 @@ import { buildAudit } from './xlsx.mjs';
 import { parseFindingsJson, parseFindingsJsonLenient, deriveDisplayVerdict, joinFindingToBlock, CLIENT_TIER_BY_COMPOSITE, projectCoverageJudgment } from '../findings-model.mjs';
 import { readStore, requiredAbsent, nonClosingAbsences } from './publish-inputs.mjs';   // — and why an absence did not close
 import { clearanceReportData } from './report-data.mjs';
+import { searchDepthRecord } from './search-depth.mjs';   // how much was read to reach the answer, as counts and tokens
 import { parseFrameworkManifest } from '../framework.mjs';
 import { rollupTokens } from '../tokens.mjs';
 import { reportIdentityFor, productCoverageNote, isRegisterOnly } from '../search-policy.mjs';
@@ -1053,7 +1054,29 @@ export async function publishReport({ runId, codename, reportMd, auditMd, findin
   // worse demo than no toggle.
   const reportNav = siteNav(poolRoot, 'report', null, '../', { anon: false });
   // `demoData` is resolved above the report.md write — one answer, every surface.
-  writeRO('report.html', renderHtml(parsed, findings, coverage, { demoData, productName, depthNote, scopeBasis, auditFile: auditFile || undefined, runId, delivery: deliv, recordsByUri, contextNotes, coverageJudgment: coverageJudgmentDisplay, markAssessment, fourAnswers, homeHref: '../index.html', nav: reportNav, chromeHref: '../assets/chrome.css', issued, asOf, verdictInfo, framework, searchedJurisdictions, caseLawByOrdinal, caseLawNotice, enforcerSignals, recordOrigin, recordOrigins: runOrigins, recordCitation: runProviderConf?.recordCitation ?? null, recordLinks: officeLinks?.byUri ?? null, providerLabel, seniorRights, findingsSchemaVersion }));
+  // ── HOW MUCH WAS READ TO REACH THE ANSWER ──────────────────────────────────────────────────────
+  // Derived here rather than in a stage so a REPUBLISH of an archived run picks the fields up with no
+  // re-run: every source below is something the run already wrote. Best-effort per source, in the house
+  // pattern — a run with no grid or no case-law layer still gets its register counts, and the absent
+  // ones report themselves as zero or `not-in-scope` rather than as a gap nobody can see.
+  let searchDepth = null;
+  try {
+    const runBase = runDir ?? dirname(reportMd);
+    const recDir = join(runBase, '_records');
+    const rdText = (p2) => { try { return readFileSync(p2, 'utf8'); } catch { return ''; } };
+    const rdJson = (p2) => { try { return JSON.parse(readFileSync(p2, 'utf8')); } catch { return null; } };
+    searchDepth = searchDepthRecord({
+      auditMd: (auditMd && existsSync(auditMd)) ? rdText(auditMd) : '',
+      recordIndex: recordsByUri ?? {},
+      recordFileNames: existsSync(recDir) ? readdirSync(recDir) : [],
+      commonLawGrid: rdJson(join(runBase, 'common-law-grid.json')),
+      caseLawText: rdText(join(dirname(reportMd), 'case-law-findings.md')),
+      registerPlan: rdJson(driverDir(runBase, 'register-plan.json')),
+    });
+    writeRO('search-depth.json', JSON.stringify(searchDepth, null, 2));
+  } catch { /* the depth record is additive — a publish never fails for want of it */ }
+
+  writeRO('report.html', renderHtml(parsed, findings, coverage, { demoData, productName, depthNote, scopeBasis, auditFile: auditFile || undefined, runId, delivery: deliv, recordsByUri, contextNotes, coverageJudgment: coverageJudgmentDisplay, markAssessment, fourAnswers, homeHref: '../index.html', nav: reportNav, chromeHref: '../assets/chrome.css', issued, asOf, verdictInfo, framework, searchedJurisdictions, caseLawByOrdinal, caseLawNotice, enforcerSignals, recordOrigin, recordOrigins: runOrigins, recordCitation: runProviderConf?.recordCitation ?? null, recordLinks: officeLinks?.byUri ?? null, providerLabel, seniorRights, findingsSchemaVersion, searchDepth }));
   // ONE report (spec 2026-07-30 §5): report.client.html is no longer written. The knockout lane's own
   // collapse note is the precedent: "two renderings of one run is how the wrong link gets sent". The
   // client host serves the same report.html through the portal's readReport() (cleaning built in) — its

package/driver/publish/render-knockout.mjs

@@ -53,6 +53,7 @@ import { demoBannerHtml } from './render.mjs';   // — the SAME banner the clea
 // fail-open; re-deriving either in a renderer would be this file starting a second status vocabulary,
 // which is the thing providers/_shared/screen.mjs exists to prevent.
 import { makeClassifyStatus, isAllClass } from '../../providers/_shared/screen.mjs';
+import { saysSomethingNew } from '../../shared/says-something-new.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -1336,32 +1337,11 @@ const SCOPE_BLOCK_TEXT = 'What this is. A fast screen for obvious blockers to us
   + 'goes on to clearance. Every conflict above links to the material we found. The audit workbook holds '
   + 'every search run, every empty result and the working notes. Register data.';
 
-/** Words that carry no claim, so their presence or absence says nothing about what a sentence asserts. */
-const STOPWORDS = new Set(['a', 'an', 'and', 'are', 'as', 'at', 'be', 'been', 'but', 'by', 'can', 'do',
-  'does', 'each', 'for', 'from', 'has', 'have', 'here', 'in', 'is', 'it', 'its', 'no', 'not', 'of', 'on',
-  'or', 'that', 'the', 'their', 'them', 'there', 'these', 'they', 'this', 'to', 'up', 'was', 'we', 'were',
-  'what', 'when', 'which', 'will', 'with', 'you', 'your']);
-
-const contentWords = (s) => String(s ?? '').toLowerCase().replace(/[^a-z0-9\s-]/g, ' ')
-  .split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
-
-/**
- * Does this line assert anything the reference text does not already assert?
- *
- * TRUE unless every content word in the line is already in the reference. An empty line has nothing to
- * say and returns false; a line with one unfamiliar word is kept. Singular/plural is folded so that
- * "conclusion" does not read as new beside "conclusions".
- */
-function saysSomethingNew(line, reference) {
-  // The stem must be IDEMPOTENT on the singular, or the fold does nothing: an earlier form stripped
-  // "es" and turned "gives" into "giv" while leaving "give" alone, so the two never matched and every
-  // caveat looked new. Strip one trailing "s" and nothing else.
-  const stem = (w) => w.replace(/ies$/, 'y').replace(/s$/, '');
-  const known = new Set(contentWords(reference).map(stem));
-  const words = contentWords(line);
-  if (!words.length) return false;
-  return words.some((w) => !known.has(stem(w)));
-}
+// THE CAVEAT FILTER IS SHARED, NOT LOCAL. `saysSomethingNew` was defined here and is now in
+// `shared/says-something-new.mjs`, because the writing-standard check asks the identical question of a
+// page's lede against its title. Two definitions of one rule is one definition and one imitation of it.
+// The stopword set and the idempotent stem travel with it; the reference text below stays here, because
+// it is this page's own words and nothing else's.
 
 function readBlock(m, framework) {
   const factors = (m.factors ?? []).filter((s) => typeof s === 'string' && s.trim());

package/driver/publish/render.mjs

@@ -1661,6 +1661,8 @@ const COV_STATE = {
  * carries EVERY significant word of the directive it names — a near-match keeps both.
  */
 const FOLLOW_UP_PREFIX = 'Follow-up / ';
+// `<axis> / <what was swept>` — the shape unitLabel composes for a plan-derived coverage unit.
+const AXIS_LABELLED = /\s\/\s/;
 const COV_STOPWORDS = new Set(['the', 'a', 'an', 'as', 'for', 'of', 'in', 'on', 'and', 'or', 'to', 'is',
   'was', 'it', 'its', 'this', 'that', 'with', 'by', 'at', 'be', 'been', 'run', 'search', 'searched']);
 const covWords = (t) => new Set(String(t || '').toLowerCase().match(/[a-z0-9]+/g)?.filter((w) => !COV_STOPWORDS.has(w)) ?? []);
@@ -1689,13 +1691,31 @@ function dedupeFollowUps(coverage) {
     // it. That is exactly the failure this function's header calls the one worth avoiding, and the
     // header was right while the code was not.
     //
-    // WHAT THIS STILL CANNOT DO, said rather than implied: it is word containment, so two genuinely
-    // different OPEN searches sharing every word of a short directive would still collapse to one. The
-    // discriminator a reader would want is which search a row names, and the rows carry no identity to
-    // join on — that is why the issue's own wording is "name the same search" rather than a rule. The
-    // narrowing here is the strongest one the data supports, and it errs toward keeping both.
+    // THE LIMITATION ABOVE STOPPED BEING HYPOTHETICAL, so it is a rule now rather than a paragraph.
+    //
+    // It read: "it is word containment, so two genuinely different OPEN searches sharing every word of a
+    // short directive would still collapse to one." Measured on a delivered report — 33 coverage entries,
+    // 31 rendered cells. Two open park rows with one- and two-word directives were erased by unrelated
+    // rows that merely mentioned those words. The client read a coverage section that never named two
+    // slices the run had deliberately disclosed, which is the failure this header calls the one worth
+    // avoiding, reached by the route the header predicted.
+    //
+    // THE DISCRIMINATOR IS THE AXIS LABEL, and it is the identity the paragraph above said was missing.
+    // A row whose area carries one — `<axis> / <what was swept>`, the shape `unitLabel` composes — is a
+    // PLAN-DERIVED COVERAGE UNIT. It is not the model restating a deferred slice; it is a different unit
+    // that happens to contain the same word. Only the model's own free-text row can BE a restatement,
+    // and that is exactly the dolphin row this function was built for: "the English word DOLPHIN as a
+    // dedicated exact search", no axis, no separator. So an axis-labelled row may no longer stand in for
+    // a composed follow-up, however many words it shares.
+    //
+    // EVIDENCE, STATED ONE-SIDED BECAUSE IT IS. Every row containing either erased directive was
+    // axis-labelled `register`, so the measured run supports the half that stops suppression. It cannot
+    // support the other half: that run has no open row WITHOUT an axis label, so nothing in it exercises
+    // "a free-text row still suppresses". The witness for that half is the dolphin incident alone, which
+    // is a real delivered page but a single one — and the arm below is what keeps it honest.
     return !written.some((w) => {
       if (COV_STATE[w?.state]?.cls === 'ok') return false;   // a searched-and-clean row reports the opposite
+      if (AXIS_LABELLED.test(String(w?.area || ''))) return false;   // a plan unit is not a restatement
       const theirs = covWords(w.area);
       return [...directive].every((word) => theirs.has(word));
     });

package/driver/publish/report-data.mjs

@@ -32,6 +32,7 @@
 // testable offline and a republished archived run reproduces its file deterministically.
 import { stripInternal, dropLabelledInternals, stripEngineInternals } from './parse.mjs';
 import { DISPOSITION_GROUP, deriveActionConditions, projectAssessmentField } from '../findings-model.mjs';
+import { clientConditions } from '../terminal-clamp.mjs';   // the reader's clause per condition — one definition, shared with the email
 
 // The client scrub choke point: the three existing rules, in the order the client HTML applies them.
 // Structural values (uris, enum tokens, dates, numbers) do not route through here — they carry no prose.
@@ -101,7 +102,7 @@ export function clearanceReportData({
       badge: verdictInfo.badge ?? null,
       band: verdictInfo.band ?? null,
       statement: clientText(verdictInfo.statement),
-      conditions: (Array.isArray(verdictInfo.reasons) ? verdictInfo.reasons : []).map(clientText).filter(Boolean),
+      conditions: clientConditions(verdictInfo).map(clientText).filter(Boolean),
     } : null,
     caption: clientText(caption),
     jurisdiction: clientText(jurisdiction),

package/driver/publish/search-depth.mjs

@@ -0,0 +1,178 @@
+// 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
+//
+// ── HOW MUCH WAS READ TO REACH THE ANSWER, AS MACHINE FIELDS ────────────────────────────────────────
+//
+// A deeper search reads more and finds no more, and until now the report could not say so: a run that
+// read 1,455 register records and cleared 432 near-names delivered a page showing 13 findings and
+// nothing of the rest. The negative evidence — the work that came back clean — existed only in the
+// audit workbook, in the engine's own working voice.
+//
+// This module derives that body of negative evidence from artifacts the run has ALREADY written. It
+// starts no search, asks no model and composes no sentence: every field here is a count, a token, or a
+// fact copied from a record. That is the whole design constraint, and it is why this lives at publish
+// time rather than in a stage — a republish of an archived run picks the fields up with no re-run.
+//
+// THE GROUP KEY IS THE PART THAT COULD HAVE GONE WRONG. Each cleared near-name is grouped by WHY it was
+// cleared, and the honest source is the register providers' closed screening vocabulary, which every
+// provider computes identically: `drop:dead` (a confidently dead status), `drop:out-of-class` (live but
+// no in-scope-class overlap), `surface:in-scope-live` / `surface:all-class` (a real in-scope candidate),
+// `deepfetch:ambiguous` (status unrecognised). A verdict and the record's own status are facts. The
+// engine's `result` paragraph is not a fact about the record, it is prose about the reasoning, and
+// classifying on it is how a report ends up asserting a reason the record does not support.
+//
+// SO THIS EMITS THREE GROUPS, NOT FOUR, AND THAT IS DELIBERATE. `dead-filing` and `different-goods` fall
+// straight out of the vocabulary. Everything else is `other` — read, in scope, and cleared on judgment.
+// A fourth group, "different word", cannot be derived from a screening verdict or a status: a name
+// cleared because it reads as a different word was `surface:in-scope-live` like any other real
+// candidate, and only the reasoning says otherwise. Splitting it would mean either reading that prose
+// or inventing a similarity rule here, and a wrong group on a client page is worse than a coarse
+// honest one. Recorded on the issue rather than guessed at.
+//
+// BREAK MATRIX:
+//   · a dead status groups as dead-filing            → break: drop the status arm, arm 1 red
+//   · an out-of-class verdict groups as goods        → break: map it to other, arm 2 red
+//   · an in-scope live name groups as other          → break: classify on the result prose, arm 3 red
+//   · a per-country count names every country read   → break: count only countries with a finding, arm 5 red
+//   · court decisions distinguishes four states      → break: collapse none-found into not-checked, arm 6 red
+
+/** The closed set a group key may take. The renderer's headings are keyed on these, never on prose. */
+export const CLEARED_GROUPS = Object.freeze(["dead-filing", "different-goods", "other"]);
+
+/** Statuses a register reports for a filing that is no longer live. Surfaced by the provider, never date-cut. */
+const DEAD_STATUS_RE = /^(?:CANCELLED|CANCELED|EXPIRED|ABANDONED|WITHDRAWN|REFUSED|DEAD|LAPSED|INVALID|SURRENDERED)\b/i;
+
+/**
+ * Why this near-name was cleared, from the two fields the engine records per name. PURE.
+ *
+ * @param {{screenVerdict?: string, status?: string}} a
+ * @returns {"dead-filing"|"different-goods"|"other"}
+ */
+export function groupForCleared({ screenVerdict, status } = {}) {
+  const v = String(screenVerdict ?? "").trim().toLowerCase();
+  const s = String(status ?? "").trim();
+  if (v.startsWith("drop:dead") || DEAD_STATUS_RE.test(s)) return "dead-filing";
+  if (v.startsWith("drop:out-of-class")) return "different-goods";
+  return "other";
+}
+
+/** One `## NRn` block's `- key: value` lines. The audit is written by a deterministic builder, so this is a contract. */
+const field = (block, key) => (block.match(new RegExp(`^- ${key}:\\s*(.*)$`, "m")) || [])[1]?.trim() ?? "";
+const noteField = (notes, key) => (notes.match(new RegExp(`${key}=([^;]+)`)) || [])[1]?.trim() ?? "";
+
+/**
+ * Every near-name the run read and cleared, register and web, as facts. PURE.
+ *
+ * The register rows carry no sentence: mark, owner, country, class, status, group and the record URI.
+ * The reasoning stays in the audit workbook, where the engine already wrote it — the owner ruled against
+ * a second client-facing sentence per name (2026-09-16), so this deliberately does not carry `result`.
+ *
+ * @param {string} auditMd            the run's `audit.md`
+ * @param {Record<string, object>} recordIndex  fetched records by URI, for the fuller mark and owner
+ */
+export function clearedNames(auditMd, recordIndex = {}) {
+  const out = { register: [], web: [] };
+  for (const block of String(auditMd ?? "").split(/^## /m).slice(1)) {
+    const title = block.split("\n")[0].trim();
+    const layer = field(block, "source_layer");
+    if (/^NR\d+/.test(title) && /register/i.test(layer)) {
+      const notes = field(block, "notes");
+      const uri = (notes.match(/URI (\S+?);/) || [])[1] ?? "";
+      const screenVerdict = noteField(notes, "screen_verdict");
+      const status = noteField(notes, "status");
+      const classes = noteField(notes, "class");
+      const country = ((uri.match(/^\/mark\/([a-z]{2})\//) || [])[1] ?? "").toUpperCase();
+      const rec = recordIndex[uri] ?? {};
+      out.register.push({
+        term: field(block, "search_term"),
+        mark: rec.markText || rec.mark || field(block, "search_term"),
+        owner: rec.owner ?? "", country, classes: rec.classes || classes,
+        status: rec.statusText || status,
+        group: groupForCleared({ screenVerdict, status: rec.statusText || status }),
+        uri,
+      });
+    } else if (!/^NR\d+/.test(title) && /common-law/i.test(layer) && !/^\(none/i.test(title)) {
+      out.web.push({ title, url: field(block, "url"), type: field(block, "type") });
+    }
+  }
+  return out;
+}
+
+/**
+ * Register records read, per country, from the run's own `_records/` listing. PURE.
+ *
+ * EVERY COUNTRY THE RUN READ, including the ones that came back clean — those are the whole point. A
+ * count keyed off the findings would list only countries with a conflict, which is the gap this closes.
+ *
+ * @param {string[]} recordFileNames  the `_records/` directory listing, named `<cc>-<id>.json`
+ */
+export function recordsByCountry(recordFileNames = []) {
+  const out = {};
+  for (const name of recordFileNames) {
+    const cc = (String(name).match(/^([a-z]{2})-/i) || [])[1];
+    if (cc) out[cc.toUpperCase()] = (out[cc.toUpperCase()] ?? 0) + 1;
+  }
+  return out;
+}
+
+/** Marketplace, web, reputation and meaning checks, from the deterministic grid the tools wrote. PURE. */
+export function sweepCounts(commonLawGrid, auditMd = "") {
+  const cells = Array.isArray(commonLawGrid?.cells) ? commonLawGrid.cells : [];
+  const counts = {
+    checks: cells.length,
+    platforms: new Set(cells.map((c) => c?.platform).filter(Boolean)).size,
+    spellings: new Set(cells.map((c) => c?.term).filter(Boolean)).size,
+    reputation: Array.isArray(commonLawGrid?.extras?.pr_risk) ? commonLawGrid.extras.pr_risk.length : 0,
+  };
+  // A run old enough to predate the grid has no machine record; its per-term log is the audit's own
+  // common-law rows. Not a fallback masking a defect — those runs have nothing else to read.
+  if (!counts.checks && auditMd) counts.checks = (String(auditMd).match(/^- source_layer: Common-law/gm) || []).length;
+  return counts;
+}
+
+/**
+ * What the court-decisions pass came back with, as one token. PURE.
+ *
+ * FOUR STATES, BECAUSE THREE OF THEM MEAN DIFFERENT THINGS TO A READER. "None found" is a result and
+ * "could not be checked" is a gap; collapsing them would let an unreachable source read as a clean
+ * negative, which is the one thing a clearance may never do. "Not in scope" is neither — the product
+ * offers the pass on a full country search only.
+ *
+ * @returns {"found"|"none-found"|"not-checked"|"not-in-scope"}
+ */
+export function courtDecisionsState(caseLawText) {
+  const t = String(caseLawText ?? "");
+  if (!t.trim()) return "not-in-scope";
+  if (/source unreachable|could not be reached|CONNECTION_CLOSED|not reachable|quota/i.test(t)) return "not-checked";
+  if (/No on-point precedent found|none found|no decisions found/i.test(t)) return "none-found";
+  return "found";
+}
+
+/** Was the name searched in a non-Latin script? Read off the plan's own terms, never asserted. PURE. */
+export function localScriptSearched(registerPlan) {
+  const entries = Array.isArray(registerPlan?.entries) ? registerPlan.entries : [];
+  return entries.some((e) => /[^\x00-\x7F]/.test(String(e?.term ?? "")));
+}
+
+/**
+ * The whole record, composed from what the run holds. PURE — every argument is already-written material.
+ *
+ * @returns {{schemaVersion: number, cleared: object, counts: object}}
+ */
+export function searchDepthRecord({ auditMd = "", recordIndex = {}, recordFileNames = [], commonLawGrid = null, caseLawText = "", registerPlan = null } = {}) {
+  const cleared = clearedNames(auditMd, recordIndex);
+  const groups = {};
+  for (const key of CLEARED_GROUPS) groups[key] = 0;
+  for (const c of cleared.register) groups[c.group] += 1;
+  return {
+    schemaVersion: 1,
+    cleared: { register: cleared.register, web: cleared.web, groups },
+    counts: {
+      recordsByCountry: recordsByCountry(recordFileNames),
+      recordsRead: recordFileNames.length,
+      sweep: sweepCounts(commonLawGrid, auditMd),
+      localScriptSearched: localScriptSearched(registerPlan),
+      courtDecisions: courtDecisionsState(caseLawText),
+    },
+  };
+}

package/driver/suite-census.json

@@ -141,6 +141,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-client-condition-never-carries-an-engine-token.test.mjs": {
+          "tests": 6,
+          "asserts": 10,
+          "skips": 0,
+          "todos": 0
+        },
         "a-codex-login-survives-its-own-refresh.test.mjs": {
           "tests": 4,
           "asserts": 18,
@@ -651,6 +657,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-refusal-with-no-near-neighbour-does-not-claim-the-search-never-ran.test.mjs": {
+          "tests": 4,
+          "asserts": 15,
+          "skips": 0,
+          "todos": 0
+        },
         "a-refused-mcp-call-is-not-a-call-nobody-made.test.mjs": {
           "tests": 7,
           "asserts": 19,
@@ -765,6 +777,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-short-named-open-slice-still-reaches-the-page.test.mjs": {
+          "tests": 5,
+          "asserts": 6,
+          "skips": 0,
+          "todos": 0
+        },
         "a-signal-immune-fixture-is-reaped-by-its-owner.test.mjs": {
           "tests": 10,
           "asserts": 20,
@@ -1631,7 +1649,7 @@
         },
         "coverage-is-disclosed-never-refused.test.mjs": {
           "tests": 10,
-          "asserts": 38,
+          "asserts": 40,
           "skips": 0,
           "todos": 0
         },
@@ -4989,6 +5007,12 @@
           "skips": 1,
           "todos": 0
         },
+        "the-report-can-say-how-much-was-read.test.mjs": {
+          "tests": 8,
+          "asserts": 23,
+          "skips": 0,
+          "todos": 0
+        },
         "the-report-carries-what-the-assessment-wrote.test.mjs": {
           "tests": 10,
           "asserts": 41,
@@ -5139,6 +5163,18 @@
           "skips": 0,
           "todos": 0
         },
+        "the-writing-standard-backlog-is-a-floor.test.mjs": {
+          "tests": 3,
+          "asserts": 8,
+          "skips": 2,
+          "todos": 0
+        },
+        "the-writing-standard-check-refuses-five-classes.test.mjs": {
+          "tests": 14,
+          "asserts": 53,
+          "skips": 0,
+          "todos": 0
+        },
         "the-xcheck-cap-counts-queries.test.mjs": {
           "tests": 9,
           "asserts": 25,
@@ -5955,7 +5991,7 @@
         },
         "home.test.ts": {
           "tests": 56,
-          "asserts": 196,
+          "asserts": 197,
           "skips": 0,
           "todos": 0
         },

package/driver/terminal-clamp.mjs

@@ -106,3 +106,44 @@ export function orderClausesForLede(clauses, reasons, guardSet) {
   const ordered = [...aligned.filter((x) => !guardSet?.has?.(x.c)), ...aligned.filter((x) => guardSet?.has?.(x.c))];
   return { clauses: ordered.map((x) => x.c), reasons: ordered.map((x) => x.r) };
 }
+
+/**
+ * THE CLIENT'S CONDITION LIST, from a verdict sidecar. PURE.
+ *
+ * TWO TEXTS, NEVER ONE — stated at the top of this module, and until now honoured at only one of the
+ * two ends. Every clamp site composes a run-record `reason` (token, counts, record ids) and a reader
+ * `clause` (the same fact in a lawyer's nouns), and `terminalClampDecision` refuses a clause that
+ * carries an engine identifier. The sidecar then persisted `reasons` alone and threw the clauses away,
+ * so every client surface had only the run-record text to render. A delivered report's conditions
+ * opened with `floor_duty_undischarged:4 of 430 floor row(s)…` while the SAME run's risk statement, one
+ * line above, read the clean clause: `riskStatement` already prefers `clauses`, so the page contradicted
+ * its own headline. This function is the other end of that rule.
+ *
+ * THE CLAUSE WINS WHERE THERE IS ONE, and the fallback is not politeness. Three machinery sites push
+ * the reason AS the clause ("machinery reasons ARE factual open-states"), so for those entries the two
+ * texts are one string and this returns it unchanged — correctly, because no second text exists to
+ * prefer. A legacy sidecar written before this change carries no `clauses` key at all and falls back
+ * entirely, which is what keeps archived runs republishable.
+ *
+ * ALIGNMENT IS BY INDEX AND THE REASONS ARE THE COUNT AUTHORITY. `orderClausesForLede` pairs the two
+ * arrays and reorders them together; a BLOCKING verdict then appends its grounds to the reasons alone,
+ * so `clauses` is legitimately SHORTER. Mapping over reasons and reaching for `clauses[i]` is what
+ * makes that safe — never `clauses.map`, which would silently drop the appended grounds.
+ *
+ * BREAK MATRIX:
+ *   · a clause replaces its token-bearing reason   → break: return reasons unchanged, arm 1 red
+ *   · a clean reason with no clause survives       → break: return "" for a missing clause, arm 2 red
+ *   · a legacy sidecar still yields its conditions  → break: require the clauses key, arm 3 red
+ *   · clauses shorter than reasons loses nothing    → break: map over clauses, arm 4 red
+ *
+ * @param {{reasons?: string[], clauses?: string[]}} sidecar  the parsed `_driver/verdict.json`
+ * @returns {string[]} one condition per reason, in the sidecar's own order
+ */
+export function clientConditions({ reasons, clauses } = {}) {
+  const rs = Array.isArray(reasons) ? reasons : [];
+  const cs = Array.isArray(clauses) ? clauses : [];
+  return rs.map((r, i) => {
+    const clause = typeof cs[i] === "string" ? cs[i].trim() : "";
+    return clause || String(r ?? "").trim();
+  }).filter(Boolean);
+}

package/driver/verify.mjs

@@ -368,14 +368,21 @@ function commonLawMeaningSeat(p, c) {
   const recordedQ = new Set(recordedRaw.map(queryKey));
   const dropped = dictated.filter((q) => !recordedQ.has(queryKey(q)));
   if (dropped.length) {
-    // ── THE REFUSAL SAYS WHICH OF TWO FAULTS THIS IS, because they need opposite remedies ──────────
+    // ── THE REFUSAL SAYS WHAT IT CAN SEE, AND STOPS SHORT OF WHAT IT CANNOT ───────────────────────
     //
-    // ABSENT: no recorded query resembles it, so the search was not run and the seat must run it.
     // UNMATCHED: something close IS recorded, so the search ran and the two spellings disagree beyond
     // what the key folds — a re-ordering, a translation, a truncation, a query the provider chose for
     // itself. Telling the seat to "re-run the missing query" in that case asks for the one thing that
     // cannot help, and that is what turned one attempt into four on a production clearance.
     //
+    // NO RESEMBLANCE: nothing recorded looks like it. This used to be reported as ABSENT — "the search
+    // was not run and the seat must run it" — and that is a claim the gate has no way to make. A query
+    // recorded under a translation, a transliteration, or the seat's own rewording resembles nothing and
+    // is not absent; the seat was then told to re-run a search that had already happened, which is the
+    // same loop, one wording-distance further out. The two states are genuinely indistinguishable from
+    // here and always will be: there is no identity to join on, which is why this comparison exists at
+    // all. So the label names the observation and the remedy carries BOTH repairs, cheap either way.
+    //
     // NO THRESHOLD DECIDES ANYTHING (owner's ruling). The nearest recorded query is shown so a person or
     // a seat can SEE the difference in one attempt; it never makes the gate pass. A similarity score
     // that could pass this gate would be a score that can hide a skipped query, which is what the gate
@@ -394,11 +401,23 @@ function commonLawMeaningSeat(p, c) {
       // every query. Below half the words in common, say nothing rather than point at a red herring.
       return bestScore >= 0.5 ? best : null;
     };
+    // THE SECOND LABEL SAYS WHAT THIS GATE KNOWS, WHICH IS LESS THAN IT USED TO CLAIM.
+    //
+    // It read `[absent from the ledger]`, and that is an assertion the gate cannot make. No near
+    // neighbour means no RECORDED query resembles this one — not that the search never ran. A query that
+    // ran and was recorded under a translation, a transliteration, a re-ordering, or the seat's own
+    // rewording clears no overlap threshold, and was then told to re-run a search that had already
+    // happened. That is the loop this whole gate was filed to break, narrowed but not closed: it needs a
+    // large wording difference now rather than a single apostrophe, and it is still reachable.
+    //
+    // The gate cannot tell the two apart and is not being asked to. There is no identity to join on —
+    // that is the entire reason the dictated-versus-recorded comparison exists. So the label states the
+    // observation, the remedy carries both cases, and no threshold decides which one a seat is told.
     const parts = dropped.slice(0, 3).map((q) => {
       const n = nearest(q);
       return n
         ? `${abbrev(q, 40)} [unmatched; nearest recorded: ${abbrev(n, 40)}]`
-        : `${abbrev(q, 40)} [absent from the ledger]`;
+        : `${abbrev(q, 40)} [no recorded query resembles this one]`;
     });
     return fail(`connotation_query_unrecorded:${parts.join(",")}${dropped.length > 3 ? ` (+${dropped.length - 3} more)` : ""}`);
   }

package/mcp-server/CHANGELOG.md

@@ -1,5 +1,13 @@
 # trademark-artifacts-mcp
 
+## 0.3.2-beta.1
+
+No changes in this release.
+
+## 0.3.2-beta.0
+
+No changes in this release.
+
 ## 0.3.1
 
 ### Patch Changes

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-artifacts-mcp",
-  "version": "0.3.1",
+  "version": "0.3.2-beta.1",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "MCP server to interrogate clearotron trademark-clearance runs — list/read artifacts, trace the full decision flow, telemetry/cost, coverage, single-run search, and a gated single-step what-if. Imports the clearotron-driver read-only; touches no driver/template/deploy files.",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clearotron",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.3.2-beta.1",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",