clearotron 0.3.1-beta.4 → 0.3.2-beta.0

package/driver/gateway.mjs

@@ -2596,29 +2596,45 @@ export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.jso
     const dropped = (lastFail.match(/connotation_query_unrecorded:(.+)$/s) || [])[1] || "";
     // ── TWO FAULTS, TWO REMEDIES, and sending the wrong one is what made this permanent ────────────
     //
-    // The gate marks each dropped query `[absent from the ledger]` or `[unmatched; nearest recorded: …]`.
-    // Absent means the search did not run and must. Unmatched means it DID run and the ledger's spelling
-    // differs beyond punctuation — re-running it changes nothing, and telling a seat to re-run is how a
-    // stage fails four times with the same string. Where both appear, both sentences are sent.
+    // The gate marks each dropped query `[unmatched; nearest recorded: …]` or `[no recorded query
+    // resembles this one]`, and the difference is what the gate can SEE, not what happened.
+    //
+    // UNMATCHED is knowable: something close is recorded, so the search ran and the wording differs.
+    // Re-running changes nothing, and telling a seat to re-run is how a stage fails four times with the
+    // same string.
+    //
+    // NO RESEMBLANCE IS NOT KNOWABLE, and this hint used to pretend otherwise. It said the query was
+    // missing and to go and run it — but a query recorded under a translation, a transliteration or the
+    // seat's own rewording resembles nothing and has already run, and that seat was then sent round the
+    // same loop the unmatched branch exists to break. The gate cannot tell the two apart; no threshold
+    // can, and a threshold that could would be one that hides a query nobody ran.
+    //
+    // So this branch stops asserting and hands over both repairs. Both are cheap, a seat can tell which
+    // applies by looking at its own ledger, and neither wastes an attempt: if the search did run, fix
+    // the row's wording; if it did not, run it and append the row. Where both labels appear, both
+    // sentences are sent, as before.
     const anyUnmatched = /\[unmatched; nearest recorded:/.test(dropped);
-    const anyAbsent = /\[absent from the ledger\]/.test(dropped);
-    hint = anyUnmatched && !anyAbsent
+    const anyUnresembled = /\[no recorded query resembles this one\]/.test(dropped);
+    hint = anyUnmatched && !anyUnresembled
       ? `these dictated meaning queries ARE recorded in ${gridLedgerName} extras.pr_risk[] under a ` +
         `different wording, which is why the driver cannot match them: ${dropped}. Do NOT re-run them — ` +
         `the search already ran and its results are already in the ledger. EDIT each row's \`query\` ` +
         `field to the query text EXACTLY as the task message dictates it, character for character, and ` +
         `leave its results untouched. The driver matches your rows to its list by that text`
-      : `every dictated meaning query owes a row, including the ones that find nothing — these are ` +
-      `missing from ${gridLedgerName} extras.pr_risk[]: ${dropped}. A query that returned NO results is ` +
-      `not an excuse to omit it: record it with an empty results array, which is the receipt that the ` +
-      `search RAN and came back clean. That is the whole point of the sweep — on an "offensive meaning" ` +
-      `query the empty answer IS the good news, and a missing row is indistinguishable from a search ` +
-      `nobody performed. Re-run ONLY the listed queries, append a row per query to extras.pr_risk[] ` +
-      `whether or not it has hits, and leave every row already recorded exactly as it is. Record each ` +
-      `query's text EXACTLY as the task message dictates it — the driver matches your rows to its list by ` +
-      `the query text, so a reworded or re-punctuated query reads as one you never ran. Where a query is ` +
-      `marked \`[unmatched; nearest recorded: …]\` it is already in the ledger under that wording: edit ` +
-      `that row's \`query\` to the dictated text rather than running the search again`;
+      : `the driver cannot match these dictated meaning queries to any row in ${gridLedgerName} ` +
+      `extras.pr_risk[]: ${dropped}. That means one of two things and the driver cannot tell which, so ` +
+      `check your own ledger and do whichever applies — both are cheap. IF THE SEARCH ALREADY RAN and ` +
+      `you recorded it under different wording — a translation, a reordering, your own phrasing — do ` +
+      `NOT run it again. EDIT that row's \`query\` field to the query text EXACTLY as the task message ` +
+      `dictates it, character for character, and leave its results untouched. IF IT NEVER RAN, run it ` +
+      `now and append a row to extras.pr_risk[]. A query that returned NO results still owes its row: ` +
+      `record it with an empty results array, which is the receipt that the search RAN and came back ` +
+      `clean. On an "offensive meaning" query the empty answer IS the good news, and a missing row is ` +
+      `indistinguishable from a search nobody performed. Either way, record each query's text EXACTLY ` +
+      `as the task message dictates it — the driver matches your rows to its list by that text, so a ` +
+      `reworded query reads as one you never ran. Touch ONLY the listed queries and leave every other ` +
+      `recorded row exactly as it is. Where a query is marked \`[unmatched; nearest recorded: …]\` the ` +
+      `driver has already found its row for you: edit that row's \`query\` and do not search again`;
   } else if (/connotation_search_missing/.test(lastFail)) {
     // — was "your PR / reputational section claims a clean meaning … but the ledger recorded ZERO
     // searches", which under the `ensure` prefix instructed the model to make the unbacked claim.

package/driver/package.json

@@ -2,7 +2,7 @@
   "name": "clearotron-driver",
   "private": true,
   "type": "module",
-  "version": "0.3.1-beta.4",
+  "version": "0.3.2-beta.0",
   "license": "AGPL-3.0-only",
   "description": "Deterministic driver for the trademark clearance workflow: orchestration in code (fan-out, fan-in barrier, gating, retries); the model does judgment leaves only, through a reasoning CLI spawned per stage.",
   "engines": {

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/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,
@@ -4593,6 +4605,12 @@
           "skips": 0,
           "todos": 0
         },
+        "the-cut-approves-its-own-parked-run.test.mjs": {
+          "tests": 4,
+          "asserts": 10,
+          "skips": 0,
+          "todos": 0
+        },
         "the-demo-account-shows-a-configured-customer.test.mjs": {
           "tests": 4,
           "asserts": 24,
@@ -5133,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,24 @@
 # trademark-artifacts-mcp
 
+## 0.3.2-beta.0
+
+No changes in this release.
+
+## 0.3.1
+
+### Patch Changes
+
+- f96c089: Fixed: A clearance for a new client can be ordered through an assistant connector without setting up a company first.
+- 56a760f: Fixed: Removing somebody's access now ends their assistant's connection on its next request. Until now an assistant that had already connected kept the access it started with for up to half an hour.
+- c05e0a7: Fixed: Ask your assistant for a client's recent searches by the client's name and it finds them. Every search in the list now says which client it was for, and which project. A search whose own record cannot be read says so, instead of appearing to belong to nobody.
+- d9798db: Fixed: A clearance that stops now always records that its notice is still owed, so a failure cannot be passed over as already handled.
+- 240673c: Fixed: Sending an access key to the engine's network address now gets a refusal that says so. It reports that the address takes an identity from the sign-in proxy and never a key.
+  
+  Fixed: That refusal also names the local door where a key is accepted. Before, it reported only a missing sign-in assertion, which sent operators to the wrong configuration.
+  
+  For operators: A program on the same machine can now reach the engine's local key door without setting a host name for it. The local door no longer applies a browser protection that only a network address needs.
+- f96c089: New: The free preview of a search lists, for each territory ordered, which registers legally bind it.
+
 ## 0.3.1-beta.4
 
 No changes in this release.

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-artifacts-mcp",
-  "version": "0.3.1-beta.4",
+  "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-beta.4",
+  "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-beta.4",
+  "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,13 @@
 # trademark-oauth-mcp-bridge
 
+## 0.3.2-beta.0
+
+No changes in this release.
+
+## 0.3.1
+
+No changes in this release.
+
 ## 0.3.1-beta.4
 
 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-beta.4",
+  "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/release-approve-parked.mjs

@@ -0,0 +1,151 @@
+#!/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
+//
+// release-approve-parked.mjs — approve the version pull request's parked CI run, so a cut does not wait
+// on a person.
+//
+// WHY A PERSON HAS BEEN CLICKING. The version pull request is authored by the repository's own Actions
+// bot, and a run triggered by a bot-authored pull request arrives `action_required`. Measured across the
+// last forty `pull_request` CI runs: every parked one is on the version branch and no human-authored
+// branch parks, so the thing that distinguishes them is the author, not a repository setting. The
+// approval endpoint works on such a run — proved against a live parked run, which moved from
+// `action_required` to `queued` — even though its documentation names fork pull requests only.
+//
+// AND WHY IT NEEDS A TOKEN RATHER THAN THE BUILT-IN ONE. `GITHUB_TOKEN` cannot approve a workflow run;
+// GitHub blocks self-approval deliberately. So this reads a separate token with Actions read and write.
+//
+// WHAT THAT PERMISSION ACTUALLY BUYS, stated because the next person deciding whether to reuse this
+// secret will read this sentence and not the permission page. Actions write is not "approve runs": it
+// also creates workflow_dispatch events, cancels any run in the repository, and deletes run logs. This
+// workflow carries `workflow_dispatch`, so the token can reach a PUBLISH by the same door a person
+// uses. It cannot push code, open or merge a pull request, or authenticate to the registry — the
+// publish credential is minted per run from this workflow's OIDC token and stored nowhere. So the
+// boundary is real but it is not "it can only do what this script does".
+//
+// IT NEVER FAILS THE CUT. No token, no parked run, an API that refuses — each prints what happened and
+// exits 0, because the cut's own wait still ends the way it always did: a person clicks, or the wait
+// expires. A step that could turn a green cut red in order to save a click would be a worse trade than
+// the click.
+//
+// BY SHA, AND ONLY THE CURRENT ONE. Approving a STALE parked run cancels the live one — CI's concurrency
+// is workflow plus ref with cancel-in-progress on non-main refs — so this resolves the version branch's
+// head at the moment it runs and approves only a run whose `head_sha` equals it.
+//
+// THE INTERVAL THAT MATTERS IS BETWEEN THE READ AND THE POST. Filtering the run list by head_sha and
+// re-checking head_sha per row guards a case the API already guarantees; no row can disagree with the
+// value it was queried by. The way this goes wrong is the HEAD going stale: the version step
+// force-pushes that branch whenever it runs, so a push landing between the list and the approval leaves
+// this approving the run on the superseded head — the exact act that cancels the live cut. The head is
+// therefore re-read immediately before each approval, and a move aborts the whole pass rather than
+// skipping one row, because if the branch moved then every id in the list is stale.
+import { argv, env, exit } from "node:process";
+import { pathToFileURL } from "node:url";
+
+const REPO = env.GITHUB_REPOSITORY || "CordilleraSarl/clearotron";
+const BRANCH = arg("--branch") || "changeset-release/main";
+const TOKEN = env.ACTIONS_APPROVE_TOKEN || "";
+
+function arg(name) { const i = argv.indexOf(name); return i === -1 ? null : argv[i + 1]; }
+const say = (s) => process.stdout.write(`release-approve-parked: ${s}\n`);
+
+async function api(path, init = {}) {
+  const r = await fetch(`https://api.github.com${path}`, {
+    ...init,
+    headers: {
+      accept: "application/vnd.github+json",
+      authorization: `Bearer ${TOKEN}`,
+      "x-github-api-version": "2022-11-28",
+      ...(init.headers ?? {}),
+    },
+  });
+  return r;
+}
+
+/**
+ * THE DECISION, SEPARATED FROM THE NETWORK so it can be driven against a table rather than matched as
+ * source text. Given the runs on a head and that head, which run ids should be approved?
+ *
+ * `event` AND `conclusion` both: the dispatched CI run on the same head is not the one the pull
+ * request's rollup reads, and approving it would do nothing while reading as success. PURE.
+ */
+export function runsToApprove(runs, head) {
+  return (Array.isArray(runs) ? runs : [])
+    .filter((r) => r?.event === "pull_request" && r?.conclusion === "action_required" && r?.head_sha === head)
+    .map((r) => r.id);
+}
+
+// The run list is PAGED, and a silent truncation here reads as "nothing parked". 100 is the API maximum;
+// the loop stops when a page comes back short, and says so if it ever hits the cap, because a cut that
+// was not approved because the list was cut off should not look like a cut with nothing to approve.
+async function allRunsOn(head) {
+  const out = [];
+  for (let page = 1; page <= 5; page++) {
+    const r = await api(`/repos/${REPO}/actions/runs?head_sha=${head}&per_page=100&page=${page}`);
+    if (!r.ok) return { ok: false, status: r.status, runs: out };
+    const batch = (await r.json())?.workflow_runs ?? [];
+    out.push(...batch);
+    if (batch.length < 100) return { ok: true, runs: out };
+  }
+  say(`more than 500 runs on this head — reading the first 500 only.`);
+  return { ok: true, runs: out };
+}
+
+// One reading of "where is the version branch now", used twice: once to choose, once immediately before
+// the approval. Null means the question could not be answered, which is never treated as "unchanged".
+async function branchHead() {
+  const br = await api(`/repos/${REPO}/branches/${encodeURIComponent(BRANCH)}`);
+  if (!br.ok) return null;
+  return (await br.json())?.commit?.sha ?? null;
+}
+
+async function main() {
+  // THE ABSENT SECRET IS THE ORDINARY CASE UNTIL THE TOKEN IS MINTED, and it must read as ordinary.
+  if (!TOKEN) {
+    say("no ACTIONS_APPROVE_TOKEN — nothing approved; the version run waits for a person, as before.");
+    return 0;
+  }
+
+  const head = await branchHead();
+  if (!head) { say(`could not read ${BRANCH} — nothing approved.`); return 0; }
+  say(`${BRANCH} is at ${head.slice(0, 7)}`);
+
+  const rr = await allRunsOn(head);
+  if (!rr.ok) { say(`could not list runs for ${head.slice(0, 7)} (${rr.status}) — nothing approved.`); return 0; }
+  const ids = runsToApprove(rr.runs, head);
+  if (!ids.length) {
+    const others = rr.runs.filter((r) => r?.conclusion === "action_required").length;
+    say(`no parked pull_request run on ${head.slice(0, 7)}${others ? ` (${others} parked on another event or head, left alone)` : ""} — nothing to approve.`);
+    return 0;
+  }
+
+  for (const id of ids) {
+    // ── THE INTERVAL THAT MATTERS IS BETWEEN THE READ AND THE POST, NOT INSIDE THE LIST ──────────────
+    //
+    // Filtering the list by head_sha and then re-checking head_sha on each row guards a case the API
+    // already guarantees: no row can disagree with the value it was queried by. What can actually go
+    // wrong is `head` itself going stale — the version step force-pushes this branch whenever it runs,
+    // so a push landing between the list and this POST leaves us approving the run on the SUPERSEDED
+    // head. That is precisely the act that cancels the live cut, because CI's concurrency is workflow
+    // plus ref with cancel-in-progress on non-main refs.
+    //
+    // So the head is re-read immediately before each approval, and a move aborts rather than skips: if
+    // the branch has moved, every id in this list is stale, not just this one.
+    const now = await branchHead();
+    if (now == null) { say(`could not re-read ${BRANCH} before approving — nothing approved.`); return 0; }
+    if (now !== head) {
+      say(`${BRANCH} moved ${head.slice(0, 7)} -> ${now.slice(0, 7)} since the run list was taken — ` +
+        `NOTHING APPROVED. Approving a run on the superseded head would cancel the live one; the cut ` +
+        `waits for a person, or for the next dispatch.`);
+      return 0;
+    }
+    const a = await api(`/repos/${REPO}/actions/runs/${id}/approve`, { method: "POST" });
+    say(a.ok ? `approved run ${id} on ${head.slice(0, 7)}.` : `run ${id} refused approval (${a.status}) — the cut still waits for a person.`);
+  }
+  return 0;
+}
+
+// RUN WHEN INVOKED, whatever the file is called. The old guard compared argv[1] to this file's NAME, so
+// a rename made the step print nothing and exit 0 — a script that never ran, wearing the face of a
+// successful no-op. Comparing the resolved URLs asks the real question instead.
+if (import.meta.url === pathToFileURL(argv[1] ?? "").href) main().then((c) => exit(c)).catch((e) => { say(`could not run (${e?.message ?? e}) — nothing approved.`); exit(0); });