clearotron 0.3.1 → 0.3.2-beta.1

package/portal-ui/dist/assets/{index-DBIs21e4.css → index-DNQpLYZF.css}

@@ -1960,8 +1960,20 @@ input.filter {
   color: var(--text-strong); white-space: nowrap;
 }
 .home2-band-label.faint { color: var(--text-faint); }
-.home2-band-count { font-size: 11.5px; color: var(--text-faint); }
+/* THE SAME SIZE AND COLOUR AS THE CAPACITY LINE OPPOSITE, because the two are one sentence read across
+   the band: what is happening on the left, how much can happen at once on the right. It carried `mono`
+   while it was a single total, which read as a machine's counter rather than as a statement. `nowrap`
+   because it is now a breakdown — "2 running · 1 paused · 2 queued" — and breaking it mid-clause puts
+   a number on its own line. */
+.home2-band-count { font-size: 11.5px; color: var(--text-faint); white-space: nowrap; }
 .home2-band-rule { height: 1px; background: var(--border-hairline); }
+
+/* A RUNNING RUN AS A ROW. The queue's grid, with the two columns a running row has and a waiting one
+   does not. Declared as a modifier rather than a new grid so the narrow-screen rule that hides columns
+   keeps one definition for both. */
+.home2-runrows { display: flex; flex-direction: column; gap: 1px; margin-bottom: 18px; }
+.home2-runrow .home2-qstep { font-size: 11.5px; color: var(--text-muted); white-space: nowrap; }
+.home2-runrow .home2-qreason { font-size: 11.5px; color: var(--text-muted); white-space: nowrap; }
 .home2-band-note {
   font-size: 11.5px; color: var(--text-faint); text-align: right;
   white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
@@ -2045,6 +2057,10 @@ input.filter {
   display: flex; align-items: center; gap: 10px;
 }
 .home2-reason { flex: 1; min-width: 0; font-size: 12.5px; color: var(--text-muted); }
+/* QUIETER THAN THE ELAPSED TIME IT FOLLOWS. The elapsed line is this run's own fact; the quote beside it
+   is the standing one for its pipeline, and a reader who wants to know how long this has been going
+   should meet that first. Same line, one step back in the hierarchy. */
+.home2-expect { font-size: 12.5px; color: var(--text-faint); white-space: nowrap; }
 .home2-reason.paused { color: var(--tone-medium); }
 .home2-reason.failed { color: var(--tone-high); }
 .home2-stop, .home2-cancel, .home2-ack {

package/portal-ui/dist/index.html

@@ -49,8 +49,8 @@
     -->
     <link rel="preconnect" href="https://api.fontshare.com" crossorigin />
     <link href="https://api.fontshare.com/v2/css?f[]=satoshi@400,500,700,900&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/portal/assets/index-ChIQsMYp.js"></script>
-    <link rel="stylesheet" crossorigin href="/portal/assets/index-DBIs21e4.css">
+    <script type="module" crossorigin src="/portal/assets/index-BsbasHjM.js"></script>
+    <link rel="stylesheet" crossorigin href="/portal/assets/index-DNQpLYZF.css">
   </head>
   <body>
     <div id="root"></div>

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.1",
   "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,13 @@
 # trademark-oauth-mcp-bridge
 
+## 0.3.2-beta.1
+
+No changes in this release.
+
+## 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.1",
   "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/freeze-example-run.mjs

@@ -29,7 +29,7 @@
 //   _driver/run.jsonl        the event log
 //   _driver/stage-inputs/    what each stage was handed
 //   _history/                pre-reopen snapshots
-// Dropping the telemetry drops `meta.tokens` (driver/publish/index.mjs:971 — the only consumer of
+// Dropping the telemetry drops `meta.tokens` (driver/publish/index.mjs:1136 rollupTokens — the only consumer of
 // rollupTokens). That is the one difference step 5 is told to expect, and it says so out loud rather than
 // normalising it away in silence.
 //
@@ -55,26 +55,26 @@ const REPO = join(dirname(fileURLToPath(import.meta.url)), "..");
 // Every entry cites the read that puts it here. `required` means publish cannot render without it.
 const FROZEN_FILES = [
   // publish/index.mjs — parseReport(reportMd), the one mandatory input
-  { path: "report.md", required: true, why: "publish/index.mjs:649 parseReport" },
-  { path: "audit.md", why: "publish/index.mjs:835 audit workbook source" },
-  { path: "findings.json", why: "publish/index.mjs:555 the per-finding machine contract" },
-  { path: "status.json", why: "publish/index.mjs:730,905 machine ledger note + markName" },
-  { path: "case-law-findings.md", why: "publish/index.mjs:660 case-law section" },
-  { path: "common-law-grid.json", why: "publish/index.mjs:788 common-law coverage" },
+  { path: "report.md", required: true, why: "publish/index.mjs:650 parseReport" },
+  { path: "audit.md", why: "publish/index.mjs:1022 auditMd, the audit workbook source" },
+  { path: "findings.json", why: "publish/index.mjs:715 readStore, the per-finding machine contract" },
+  { path: "status.json", why: "publish/index.mjs:913 machineLedgerNote + markName" },
+  { path: "case-law-findings.md", why: "publish/index.mjs:849 clPath, the case-law section" },
+  { path: "common-law-grid.json", why: "publish/index.mjs:973 commonLawJoinedTerms, common-law coverage" },
   // publish/index.mjs — the _driver sidecars it reads by name
-  { path: "_driver/receipts.json", why: "publish/index.mjs:592" },
-  { path: "_driver/senior-rights.json", why: "publish/index.mjs:599" },
-  { path: "_driver/verdict.json", why: "publish/index.mjs:604" },
-  { path: "_driver/framework.json", why: "publish/index.mjs:608 the bands the run was rated under" },
-  { path: "_driver/register-plan.json", why: "publish/index.mjs:634" },
-  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:641 fallback for register-plan" },
-  { path: "_driver/enforcer-signals.json", why: "publish/index.mjs:672" },
-  { path: "_driver/predelivery-lint.json", why: "publish/index.mjs:699,713" },
-  { path: "_driver/escalation-state.json", why: "publish/index.mjs:714" },
-  { path: "_driver/reasoning-integrity.json", why: "publish/index.mjs:715" },
-  { path: "_driver/corrections-state.json", why: "publish/index.mjs:716" },
-  { path: "_driver/search-policy.json", why: "publish/index.mjs:768,806 level + stage label" },
-  { path: "_driver/profile.json", why: "publish/index.mjs:920 + report-registry.mjs:42 customer key" },
+  { path: "_driver/receipts.json", why: "publish/index.mjs:761 fetchReceipts" },
+  { path: "_driver/senior-rights.json", why: "publish/index.mjs:787 seniorRights" },
+  { path: "_driver/verdict.json", why: "publish/index.mjs:792 verdictInfo" },
+  { path: "_driver/framework.json", why: "publish/index.mjs, the frozen band vocabulary the run was rated under" },
+  { path: "_driver/register-plan.json", why: "publish/index.mjs:820 scopeBasis" },
+  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:821 searchedJurisdictions, the fallback for register-plan" },
+  { path: "_driver/enforcer-signals.json", why: "publish/index.mjs:861 esPath" },
+  { path: "_driver/predelivery-lint.json", why: "publish/index.mjs:170 lintSink" },
+  { path: "_driver/escalation-state.json", why: "publish/index.mjs:171 escSink" },
+  { path: "_driver/reasoning-integrity.json", why: "publish/index.mjs:898 integritySink" },
+  { path: "_driver/corrections-state.json", why: "publish/index.mjs:172 correctionsSink" },
+  { path: "_driver/search-policy.json", why: "publish/index.mjs:955 searchPolicy, level + stage label" },
+  { path: "_driver/profile.json", why: "publish/index.mjs reads the frozen profile; report-registry.mjs:42 republishRun, customer key" },
 ];
 
 // ── THE KNOCKOUT LANE IS A DIFFERENT WORKSPACE, AND report.md IS NOT IN IT ─
@@ -91,22 +91,22 @@ const KNOCKOUT_FILES = [
   { path: "knockout-assessment.md", why: "the merged prose the lane writes (gateway.mjs:184)" },
   { path: "knockout-frame.md", why: "the batch scope note (gateway.mjs:65)" },
   { path: "email-body.md", why: "the delivery prose the lane writes beside the assessment" },
-  { path: "status.json", why: "publish/index.mjs:730,905 machine ledger note + markName" },
-  { path: "audit.md", why: "publish/index.mjs:835 audit workbook source" },
+  { path: "status.json", why: "publish/index.mjs:913 machineLedgerNote + markName" },
+  { path: "audit.md", why: "publish/index.mjs:1022 auditMd, the audit workbook source" },
   // The _driver sidecars publishKnockout reads by name. framework.json is REQUIRED and says so at its
   // call site: a knockout re-rendered under today's bands would silently restate its verdict.
   { path: "_driver/framework.json", required: true, why: "report-registry.mjs:68 the bands it was rated under" },
   { path: "_driver/search-policy.json", why: "report-registry.mjs:71 level + stage label" },
   { path: "_driver/profile.json", why: "report-registry.mjs:72 customer key and the delivery overlay" },
-  { path: "_driver/verdict.json", why: "publish/index.mjs:604" },
-  { path: "_driver/receipts.json", why: "publish/index.mjs:592" },
+  { path: "_driver/verdict.json", why: "publish/index.mjs:792 verdictInfo" },
+  { path: "_driver/receipts.json", why: "publish/index.mjs:761 fetchReceipts" },
   // THE COUNT SIDECARS, AND THE PROOF IS WHAT FOUND THEM. Without register-counts.json the republished
   // meta carries `registerCounts: undefined` where the source carried the provider, the taken-at stamp
   // and the per-mark counts — so the workbook's Register column and every counted figure in the
   // knockout report render empty (publish/knockout.mjs:140-155). Named by stages-knockout.mjs:32,41.
   { path: "_driver/register-counts.json", why: "publish/knockout.mjs:140-155 counted figures + the Register column" },
   { path: "_driver/register-records.json", why: "stages-knockout.mjs:41 the terms behind the close-variation axis" },
-  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:641 fallback for register-plan" },
+  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:821 searchedJurisdictions, the fallback for register-plan" },
 ];
 
 /** The allowlist for a template. One place, so a new template cannot half-exist. */
@@ -161,8 +161,8 @@ const SCRUB = [
 // what varies and why, and step 5 prints them — a normalisation nobody can see is a normalisation that
 // hides the next real difference.
 const VOLATILE = [
-  { id: "issued", re: /\d{4}-\d{2}-\d{2} · \d{2}:\d{2} [A-Z]{2,5}/g, sub: "<issued>", why: "publish/index.mjs:520 generation stamp, firm locale" },
-  { id: "iso-timestamp", re: /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, sub: "<ts>", why: "publish/index.mjs:665 asOf / :1067 issuedAt" },
+  { id: "issued", re: /\d{4}-\d{2}-\d{2} · \d{2}:\d{2} [A-Z]{2,5}/g, sub: "<issued>", why: "publish/index.mjs, the generation stamp in the firm locale" },
+  { id: "iso-timestamp", re: /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, sub: "<ts>", why: "publish/index.mjs:666 asOf" },
 ];
 
 // ── REWRITES — what is CHANGED on the way out, as opposed to what is refused ───────────────────────

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"
+  ]
+}