clearotron 0.3.1 → 0.3.2-beta.0

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/suite-census.json

@@ -651,6 +651,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 +771,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,
@@ -5139,6 +5151,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,

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,9 @@
 # trademark-artifacts-mcp
 
+## 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.0",
   "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.0",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

package/portal-ui/package.json

@@ -2,7 +2,7 @@
   "name": "portal-ui",
   "private": true,
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.3.2-beta.0",
   "license": "AGPL-3.0-only",
   "description": "The unified trademark portal UI. One address, one login: who you are decides what you see. Built as a static bundle, served by driver/portal-service.mjs — the browser never reaches profile-service or recipe-service.",
   "engines": {

package/providers/oauth-mcp-bridge/CHANGELOG.md

@@ -1,5 +1,9 @@
 # trademark-oauth-mcp-bridge
 
+## 0.3.2-beta.0
+
+No changes in this release.
+
 ## 0.3.1
 
 No changes in this release.

package/providers/oauth-mcp-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-oauth-mcp-bridge",
-  "version": "0.3.1",
+  "version": "0.3.2-beta.0",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "OAuth 2.1 MCP stdio bridge used by the engine's case-law gather stage (courtlistener / legaldatahunter).",

package/scripts/mint-writing-standard-backlog.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// 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
+//
+// RE-MINT THE WRITING-STANDARD BACKLOG — the per-file, per-class count that may only go down.
+//
+//   node scripts/mint-writing-standard-backlog.mjs            # report the delta, change nothing
+//   node scripts/mint-writing-standard-backlog.mjs --check    # ... and exit 1 if the file is out of date
+//   node scripts/mint-writing-standard-backlog.mjs --apply    # write it
+//
+// THE ONLY REASON TO RUN `--apply` IS THAT THE NUMBER WENT DOWN. Nothing here refuses to write a higher
+// one — a table that could not record growth would be unable to describe a tree somebody widened a class
+// over — but the floor arm refuses the growth itself, and it reads the committed file rather than this
+// script's output. So an author who mints upward has recorded the regression rather than absorbed it.
+// The two halves are deliberately not the same program.
+//
+// WHAT THE STANDING POPULATION ACTUALLY IS, so nobody reads the number as noise: nine of it is the
+// knockout's scope block and the clearance renderer's coverage paragraph — the sentences the writing
+// standard quotes as what not to write, still on the page. Two are a reviewer-only marker that reaches
+// the delivered HTML. One is a screen whose only heading is the mark its run was ordered for. One is an
+// environment name passed as an argument, which this check reads as printed text because a string
+// literal is the only site it can see; that one is a false positive and is recorded rather than
+// special-cased, because a special case for it would be a hole the size of every string argument.
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CLASSES, censusOf } from "../shared/writing-standard-classes.mjs";
+import { publishedOf } from "../shared/reference-guard-classes.mjs";
+import { trackedFiles, skipReason } from "../shared/tracked-files.mjs";
+import { isEntrypoint } from "../shared/is-entrypoint.mjs";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const FIXTURE = join(ROOT, "driver/test/fixtures/writing-standard-backlog.json");
+const GUARD = "writing-standard-backlog";
+
+/** The tree's current census, as the fixture records it. */
+export function mint() {
+  const tracked = trackedFiles(GUARD, { root: ROOT });
+  if (tracked === null) return null;
+  // THE SAME POPULATION THE FLOOR READS, from the same helper. A mint over the index and a floor over
+  // HEAD would disagree under the overlay, and `--check` would report a difference that is only the two
+  // instruments asking different questions.
+  const p = publishedOf(tracked, ROOT);
+  if (p.error) { console.error(`mint-writing-standard-backlog: ${p.error}`); process.exit(2); }
+  if (p.laid) console.log(`mint-writing-standard-backlog: ${p.laid} tracked path(s) are not in HEAD — laid over this checkout, not published in it, and not counted`);
+  const c = censusOf(p.files, (f) => readFileSync(join(ROOT, f), "utf8"));
+  return { classes: CLASSES.map((x) => x.id), total: c.total, files: c.files };
+}
+
+/** Per-class totals, for a reader who wants to know WHICH number moved. */
+export const byClass = (table) =>
+  CLASSES.map((c, i) => [c.id, Object.values(table.files).reduce((a, v) => a + v[i], 0)]);
+
+function main() {
+  const apply = process.argv.includes("--apply");
+  const check = process.argv.includes("--check");
+
+  const now = mint();
+  // A COULD-NOT-LOOK EXITS 2, never 0. Outside a checkout there is no corpus, and a mint that wrote an
+  // empty table here would replace the whole backlog with nothing and call it a repair.
+  if (now === null) { console.error(`mint-writing-standard-backlog: ${skipReason(GUARD)}`); process.exit(2); }
+
+  console.log(`writing-standard residue: ${now.total} hit(s) across ${Object.keys(now.files).length} file(s)`);
+  for (const [id, n] of byClass(now)) console.log(`  ${String(n).padStart(5)}  ${id}`);
+
+  let was = null;
+  try { was = JSON.parse(readFileSync(FIXTURE, "utf8")); } catch { /* first mint */ }
+
+  const next = JSON.stringify(now, null, 2) + "\n";
+  const same = was && JSON.stringify(was, null, 2) + "\n" === next;
+  if (same) { console.log("the backlog is current"); return; }
+
+  if (was) {
+    const delta = now.total - was.total;
+    console.log(`\ntotal ${was.total} → ${now.total} (${delta >= 0 ? "+" : ""}${delta})`);
+  }
+  if (apply) { writeFileSync(FIXTURE, next); console.log("written"); return; }
+  console.log("\nre-run with --apply to write it");
+  if (check) process.exit(1);
+}
+
+if (isEntrypoint(import.meta.url)) main();

package/scripts/writing-standard-check.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// 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
+//
+// WHAT THIS CHANGE ADDS TO A CUSTOMER SURFACE IS REFUSED. What is already here is not this check's business.
+//
+//   node scripts/writing-standard-check.mjs [--base <ref>]
+//
+// The standard is `docs/writing-standard.md`, and the prose rules under it are `docs/writing-rules.md`.
+// This refuses the five classes a machine can judge; the classes and the reasoning behind each site rule
+// are in `shared/writing-standard-classes.mjs`, next to the table, because that is where the next person
+// changing one will be looking.
+//
+// ── WHY THIS IS DIFF-SHAPED AND NOT A SWEEP ──────────────────────────────────────────────────────
+//
+// Three of the five classes have a standing population in this tree — the knockout's scope block and the
+// clearance renderer's coverage caveat are the very sentences the standard quotes as what not to write,
+// and they are still on the page. A guard that refused them all would refuse every pull request from its
+// first day, and a guard everybody bypasses protects nothing. So this one asks the smaller question that
+// has a clean answer: did THIS change add another.
+//
+// The standing population is not thereby accepted. It is counted, per file and per class, in
+// `driver/test/fixtures/writing-standard-backlog.json`, and the floor beside it refuses any file that
+// grows. Between the two the number can only fall.
+//
+// ── TWO SHAPES OF CLASS, AND WHY THE SECOND CANNOT BE A LINE READ ───────────────────────────────
+//
+// `engineering-identifier`, `internal-marker` and `known-caveat` are properties of text, so an added line
+// carries them. `eyebrow-heading` and `restating-lede` are not: "this screen writes its own page heading"
+// is a property of a FILE, and "this lede restates its title" needs the two lines at once. Adding a lede
+// under an existing title adds one line and creates the offence; a line-only reading would miss it.
+//
+// So both shapes are evaluated against the file as it stands at HEAD, and the DIFF decides only whether
+// this change is answerable for what it finds: a line class must have its line in the added set; a block
+// class must have its file in the changed set. That is a deliberate widening of "reads the lines a change
+// adds", and it is the only way the last two classes mean anything.
+//
+// ── AN EMPTY DIFF IS A LEGITIMATE PASS, AND IT IS PRINTED AS ONE ────────────────────────────────
+//
+// A pull request can touch only files this check does not read. The count is printed either way, so a
+// reader can tell "looked and found nothing" from "had nothing to look at".
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { CLASSES, fileOffences, isExempt } from "../shared/writing-standard-classes.mjs";
+
+const baseArg = () => {
+  const i = process.argv.indexOf("--base");
+  return i === -1 ? null : process.argv[i + 1];
+};
+
+/**
+ * The added lines of a diff, as `{ path, lines: Set<number> }` per file.
+ *
+ * `--unified=0` so nothing but genuinely added text is read: with context lines a neighbouring sentence
+ * would be reported as though this change wrote it, and a guard that blames the wrong line is one people
+ * learn to ignore. The hunk header carries the new-side start and count, which is what maps an added line
+ * back to its number in the file at HEAD.
+ */
+export function addedByFile(diffText) {
+  const out = new Map();
+  let path = null;
+  let nextLine = 0;
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("+++ b/")) { path = line.slice(6); if (!out.has(path)) out.set(path, new Set()); continue; }
+    if (line.startsWith("+++ ") || line.startsWith("--- ")) continue;
+    const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (hunk) { nextLine = Number(hunk[1]); continue; }
+    if (line.startsWith("+") && path) { out.get(path).add(nextLine); nextLine++; continue; }
+    if (line.startsWith("-")) continue;
+    nextLine++;
+  }
+  return out;
+}
+
+function main() {
+  const base = baseArg() || "origin/main";
+  let diff;
+  try {
+    diff = execFileSync("git", ["diff", "--unified=0", `${base}...HEAD`], { encoding: "utf8", maxBuffer: 1 << 28 });
+  } catch (e) {
+    console.error(`writing-standard-check: cannot diff against ${base}: ${e.message.split("\n")[0]}`);
+    process.exit(2);
+  }
+
+  const added = addedByFile(diff);
+  const lineClasses = new Set(["engineering-identifier", "internal-marker", "known-caveat"]);
+  const hits = [];
+  let read = 0;
+
+  for (const [path, lines] of added) {
+    if (isExempt(path)) continue;
+    let text;
+    try { text = readFileSync(path, "utf8"); } catch { continue; }   // deleted in this change
+    read += lines.size;
+    for (const o of fileOffences(path, text)) {
+      // A LINE CLASS ANSWERS FOR ITS LINE; A BLOCK CLASS ANSWERS FOR ITS FILE. Holding a block class to
+      // the added-line test would excuse the case it exists for — a lede added under a title that was
+      // already there, where the offending pair is one new line and one old one.
+      if (lineClasses.has(o.id) && !lines.has(o.line)) continue;
+      hits.push({ path, ...o });
+    }
+  }
+
+  console.log(`writing-standard-check: read ${read} added line(s) in ${added.size} file(s) against ${base}`);
+  if (!hits.length) return;
+
+  // GROUPED BY CLASS, because the remedy is per class and a flat list makes the reader derive it five
+  // times. Each heading is said once, then the lines it applies to.
+  console.error(`\n${hits.length} line(s) added that a customer surface must not carry:\n`);
+  for (const { id, why } of CLASSES) {
+    const mine = hits.filter((h) => h.id === id);
+    if (!mine.length) continue;
+    console.error(`  ${id} — ${why}`);
+    for (const h of mine) console.error(`    ${h.path}:${h.line}\n      ${h.token}`);
+    console.error("");
+  }
+  console.error("  The standard is docs/writing-standard.md. It never rewrites: a rewritten sentence is a");
+  console.error("  sentence nobody reviewed, and a report is the one document a reader may trust literally.\n");
+  process.exit(1);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();

package/shared/says-something-new.mjs

@@ -0,0 +1,62 @@
+// 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
+//
+// DOES THIS SENTENCE ASSERT ANYTHING ITS REFERENCE DOES NOT?
+//
+// One question, two callers. The knockout renderer asks it of a model-written caveat against the scope
+// block the page already prints, and drops the caveat when the answer is no. The writing-standard check
+// asks it of a page's lede against that page's title, and refuses the lede when the answer is no. The
+// two are the same rule — "this line adds nothing to the line above it" — and they were one function
+// private to the renderer until the check needed it.
+//
+// LIFTED RATHER THAN COPIED, AND THAT IS THE WHOLE POINT. Two definitions of one rule is one definition
+// and one imitation of it, and the imitation is whichever the reader did not run. A copy here would
+// drift the first time either caller tuned its stopword list, and the drift would be invisible: both
+// sides would keep passing their own tests.
+//
+// ── THE STEM MUST BE IDEMPOTENT ON THE SINGULAR ─────────────────────────────────────────────────
+//
+// Carried over from the renderer with the defect it had already been repaired for, stated here so it is
+// not reintroduced. An earlier form stripped a trailing "es" — which turned "gives" into "giv" while
+// leaving "give" alone, so the two never matched and every caveat read as new. The fold has to map the
+// plural onto the singular AND leave the singular where it is. Strip one trailing "s" and nothing else.
+
+/**
+ * Words that carry no claim, so their presence or absence says nothing about what a sentence asserts.
+ *
+ * Exported because a caller comparing two short strings — a title against a lede — can be left with no
+ * content words at all, and that case needs naming rather than inferring from a false return.
+ */
+export 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']);
+
+/** The words in a string that carry a claim: longer than two characters, and not a stopword. */
+export const contentWords = (s) => String(s ?? '').toLowerCase().replace(/[^a-z0-9\s-]/g, ' ')
+  .split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+
+/** Fold plural onto singular. Idempotent on the singular, which is the property that makes it work. */
+export const stem = (w) => w.replace(/ies$/, 'y').replace(/s$/, '');
+
+/**
+ * Does `line` assert anything `reference` 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 and plural are folded, so
+ * "conclusion" does not read as new beside "conclusions".
+ *
+ * THE TEST IS SUBSET, NOT SIMILARITY, and the difference is the whole safety argument for the renderer's
+ * use of it: a caveat is dropped only when EVERY content word in it already appears in the reference. A
+ * caveat making any new claim survives.
+ *
+ * @param {string} line the sentence being judged
+ * @param {string} reference the text it is judged against
+ * @returns {boolean}
+ */
+export function saysSomethingNew(line, reference) {
+  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)));
+}

package/shared/writing-standard-caveats.json

@@ -0,0 +1,14 @@
+{
+  "note": "The caveat sentences the writing standard forbids, held as data rather than in shared/writing-standard-classes.mjs. A class list that reprints its own specimens counts itself, and that module is read by the census that counts them. Matching is case-insensitive and whitespace-flattened, over a file's joined printed text, so a sentence built by string concatenation across source lines is still one sentence. Keep each entry long enough to be unambiguous: a fragment short enough to occur in ordinary prose will match ordinary prose.",
+  "sentences": [
+    "What it is not. A clearance search.",
+    "We drew no register conclusions and give no filing advice.",
+    "A name that passes here is not clear",
+    "A count is not a conflict",
+    "No coverage record was produced for this run.",
+    "This section normally lists what each search covered",
+    "Ask us before relying on it",
+    "the Japan adapter was unavailable this session",
+    "Source routing attempted"
+  ]
+}