clearotron 0.3.2-beta.7 → 0.3.2-beta.9

package/scripts/ask-ai-render-check.mjs

@@ -77,6 +77,7 @@ if (shotsDir) mkdirSync(shotsDir, { recursive: true })
 // `productName` is resolved through the same expression portal-service.mjs evaluates, never typed: the
 // sibling instruments' rule, and it holds here for the same reason.
 const { reportIdentityFor } = await import('../driver/search-policy.mjs')
+const { prepareReportForEmbed } = await import('../driver/portal-report.mjs')
 
 const KEY = 'acme'
 const NAME = 'Acme'
@@ -127,6 +128,19 @@ const DECKS = {
                  stdio: { command: 'node server.mjs', note: 'from this install', verify: 'it prints ready' } },
 }
 let deck = 'connected'
+// WHICH DOCUMENT THE FRAME HOLDS. The stub below for every state about the header; for a finding's own
+// button, a document put through the same preparation the portal serves a report with, so the press
+// travels the real injected script to the real listener. Two cards at fixed places: a numbered finding,
+// and an "Also considered" card, which carries the button and no number.
+let reportDoc = 'stub'
+const FINDING_DOC = () => prepareReportForEmbed(`<!doctype html><html><head><meta charset="utf-8"><title>report</title></head>
+<body style="margin:0;font-family:sans-serif;background:#fff;height:400px">
+<div class="card" id="c3" style="position:absolute;top:40px;left:20px"><div class="cardhead"><span class="fnum">3</span>
+<button class="ask-fi no-print" style="width:240px;height:32px">\u2726 Ask AI about this finding</button></div></div>
+<div class="card ruled" style="position:absolute;top:140px;left:20px"><div class="cardhead">
+<button class="ask-fi no-print" style="width:240px;height:32px">\u2726 Ask AI about this finding</button></div></div>
+<script>parent.postMessage({ source: 'cordillera-report', type: 'controls', commands: ['exportPDF'] }, '*');</script>
+</body></html>`, {}).html
 
 const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.svg': 'image/svg+xml', '.json': 'application/json' }
 const json = (res, body) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify(body)) }
@@ -143,6 +157,10 @@ const server = createServer((req, res) => {
   // A real document, because a 404 in the frame changes what Result draws around it. Its CONTENT is not
   // this file's subject — render-check.mjs owns the report's own layout. It announces the commands and
   // the height a published report's bridge announces, so the header draws the Export menu a reader meets.
+  if (p.startsWith('/portal/report/') && reportDoc === 'finding') {
+    res.writeHead(200, { 'content-type': 'text/html' })
+    return res.end(FINDING_DOC())
+  }
   if (p.startsWith('/portal/report/')) {
     res.writeHead(200, { 'content-type': 'text/html' })
     return res.end(`<!doctype html><meta charset="utf-8"><title>report</title>
@@ -409,6 +427,77 @@ await value('(() => { window.__pressContinue = true; return true })()')
 const back = await value(CONTINUE)
 const arrived = await value(PROBE)
 
+// ── a finding's own button, pressed INSIDE the report ──
+//
+// A REAL CLICK AT THE BUTTON'S PLACE, not a message posted by this script: the document is sandboxed to a
+// null origin and the point is the whole path — the injected script hears the press, posts it, and the
+// report screen opens its control. The cards sit at fixed places in the document, so the frame's own
+// position on the page is all that has to be measured.
+const pressInFrame = async (top) => {
+  await value('(() => { window.scrollTo(0, 0); return true })()')
+  await new Promise((r) => setTimeout(r, 200))
+  const at = await value(`(() => { const f = document.querySelector('iframe'); if (!f) return null; const r = f.getBoundingClientRect(); return { x: r.left, y: r.top } })()`)
+  if (!at) return false
+  const x = Math.round(at.x + 140), y = Math.round(at.y + top + 16)
+  for (const type of ['mousePressed', 'mouseReleased']) await cmd('Input.dispatchMouseEvent', { type, x, y, button: 'left', clickCount: 1 })
+  await new Promise((r) => setTimeout(r, 400))
+  return true
+}
+const PANEL = `(() => {
+  const flat = (s) => (s || '').replace(/\\s+/g, ' ').trim();
+  const anchor = document.querySelector('[data-ask-ai]');
+  const float = anchor ? anchor.querySelector('.float') : null;
+  return { open: !!float, anchorState: anchor ? anchor.getAttribute('data-ask-ai') : null,
+    head: float && float.querySelector('.ask-ai-head') ? flat(float.querySelector('.ask-ai-head').textContent) : null,
+    text: float ? flat(float.innerText) : null,
+    checked: float ? [...float.querySelectorAll('[role="radio"]')].map(r => r.getAttribute('aria-checked')) : [] };
+})()`
+// THE BUTTON'S OWN OPEN STATE, AND THE CARET THAT TIES THE PANEL TO IT. Both are CSS, so both are read
+// off the browser: a selector that never matched anything would still be in the stylesheet, and a
+// source-text arm over it would pass on a panel a reader sees floating loose over the header.
+const BUTTON = `(() => {
+  const b = document.querySelector('[data-ask-ai] > button');
+  if (!b) return null;
+  const s = getComputedStyle(b);
+  return { expanded: b.getAttribute('aria-expanded'), background: s.backgroundColor, border: s.borderTopColor };
+})()`
+const CARET = `(() => {
+  const f = document.querySelector('[data-ask-ai] .float');
+  if (!f) return null;
+  const edge = getComputedStyle(f, '::before'), fill = getComputedStyle(f, '::after'), panel = getComputedStyle(f);
+  return { edge: edge.borderBottomWidth, edgeColour: edge.borderBottomColor, panelBorder: panel.borderTopColor,
+    fill: fill.borderBottomWidth, fillColour: fill.borderBottomColor, panelFill: panel.backgroundColor, above: edge.top };
+})()`
+reportDoc = 'finding'
+deck = 'connected'; await visit()
+await value('(() => { window.__opened = []; window.open = (href) => { window.__opened.push(href); return null; }; return true })()')
+const findingPressed = await pressInFrame(40)
+const fromFinding = await value(PANEL)
+await capture('ask-ai-from-finding')
+const caret = await value(CARET)
+const openButton = await value(BUTTON)
+// PRESSED TWICE, THE SAME BUTTON SHUTS IT. A third press brings it back — which is also the state the
+// questions below need, so this measurement leaves the deck exactly as it found it.
+await pressInFrame(40)
+const closedBySecondPress = await value(PANEL)
+const shutButton = await value(BUTTON)
+await pressInFrame(40)
+const reopened = await value(PANEL)
+const findingAsks = []
+for (const i of QUESTIONS.keys()) {
+  if (i > 0) { await pressInFrame(40) }
+  findingAsks.push(await value(ASK(i)))
+}
+// The header's own button afterwards is about the whole report again.
+const headerAfter = await value(`(async () => { document.querySelector('[data-ask-ai] > button').click(); await new Promise(r => setTimeout(r, 250)); return ${PANEL} })()`)
+await value(`(async () => { document.querySelector('[data-ask-ai] > button').click(); await new Promise(r => setTimeout(r, 200)); return true })()`)
+await pressInFrame(140)
+const fromUnnumbered = await value(PANEL)
+deck = 'neverBefore'; await visit()
+await pressInFrame(40)
+const findingNotConnected = await value(PANEL)
+reportDoc = 'stub'
+
 deck = 'cannotTell';   await visit(); const unknown = await value(PROBE)
 deck = 'noConnector';  await visit(); const none = await value(PROBE)
 deck = 'localOnly';    await visit(); const local = await value(PROBE)
@@ -526,6 +615,43 @@ ok(none.drawn === false, `no connector: a button was drawn that can do nothing
 ok(local.drawn && local.opened, `local only: the case the old panel stranded is stranded again — ${show(local)}`)
 ok(local.anchorState === 'ask' && local.radios.length === 4, `local only: ${show(local.anchorState)} with ${local.radios.length} question(s)`)
 
+// ── a finding's own button: the press reaches the control, and the finding is named ──
+const FINDING_REPORT = `finding 3 of ${REPORT}`
+ok(findingPressed, 'a finding: the report frame was not on the page to press inside')
+ok(fromFinding && fromFinding.open && fromFinding.anchorState === 'ask',
+  `a finding: pressing "Ask AI about this finding" inside the report opened nothing — ${show(fromFinding)}`)
+ok(fromFinding && fromFinding.head === `${MARK} · finding 3 · ${PRODUCT_NAME} · searched ${ISO_DATE}`,
+  `a finding: the panel's first line reads ${show(fromFinding?.head)}, not the finding named beside the mark`)
+ok(show(fromFinding?.checked) === show(['true', 'false', 'false', 'false']), `a finding: the first question is not the one selected — ${show(fromFinding)}`)
+
+// ── the panel reads as this button's, and one button opens and shuts it ──
+ok(caret && caret.edge === '7px' && caret.fill === '7px',
+  `the panel draws no caret, so it reads as chrome floating over the header rather than as this button's — ${show(caret)}`)
+ok(caret && caret.edgeColour === caret.panelBorder && caret.fillColour === caret.panelFill,
+  `the caret is not the panel's own edge continuing — ${show(caret)}`)
+ok(caret && caret.above.startsWith('-'), `the caret sits at ${show(caret?.above)}, not above the panel pointing at the button`)
+ok(openButton && openButton.expanded === 'true', `with the panel open the button says expanded=${show(openButton?.expanded)}`)
+ok(shutButton && shutButton.expanded === 'false', `with the panel shut the button says expanded=${show(shutButton?.expanded)}`)
+ok(openButton && shutButton && openButton.background !== shutButton.background && openButton.border !== shutButton.border,
+  `the button is drawn the same open as shut, so nothing on the page says which control the panel belongs to — ${show({ open: openButton, shut: shutButton })}`)
+ok(closedBySecondPress && closedBySecondPress.open === false,
+  `a finding pressed twice: the second press reopened the panel instead of closing it — ${show(closedBySecondPress)}`)
+ok(reopened && reopened.open && reopened.head === `${MARK} · finding 3 · ${PRODUCT_NAME} · searched ${ISO_DATE}`,
+  `a finding pressed a third time: the panel did not come back on that finding — ${show(reopened)}`)
+const FINDING_TYPED = [`Brief me on ${FINDING_REPORT}.`, `Explain the main risks in ${FINDING_REPORT}.`,
+  `What needs further investigation in ${FINDING_REPORT}?`, `How would narrower goods change the assessment in ${FINDING_REPORT}?`]
+for (const [i, press] of findingAsks.entries()) {
+  const href = press?.opened?.[press.opened.length - 1] ?? ''
+  const typed = (() => { try { return new URL(href).searchParams.get('q') } catch { return null } })()
+  ok(typed === FINDING_TYPED[i], `a finding, question ${i + 1}: the assistant opens with ${show(typed)}, not ${show(FINDING_TYPED[i])}`)
+}
+ok(headerAfter && headerAfter.open && headerAfter.head === `${MARK} · ${PRODUCT_NAME} · searched ${ISO_DATE}`,
+  `after a finding, the header's own Ask AI still names the finding rather than the report — ${show(headerAfter)}`)
+ok(fromUnnumbered && fromUnnumbered.open && fromUnnumbered.head === `${MARK} · ${PRODUCT_NAME} · searched ${ISO_DATE}`,
+  `a card with no number: its button opened nothing, or named a finding it does not have — ${show(fromUnnumbered)}`)
+ok(findingNotConnected && findingNotConnected.open && findingNotConnected.anchorState === 'connect' && /Connect your AI first/.test(findingNotConnected.text ?? ''),
+  `a finding, not connected: the press did not open the unchanged connect panel — ${show(findingNotConnected)}`)
+
 // ── NO ADDRESS AND NO COPY LINK, in any state that draws ──
 for (const [name, r] of [['connected', connected], ['never connected', never], ['could not tell', unknown], ['local only', local]]) {
   ok(!r.hasAddress, `${name}: a connector address is on the report again — ${show(r.text)}`)
@@ -537,5 +663,5 @@ if (fail.length) {
   console.error(`ask-ai-render-check: ${fail.length} thing(s) a reader would meet`)
   process.exit(1)
 }
-console.log(`ask-ai-render-check: the header, both panels and the unmeasured state render; all four questions reach the link typed in; Set it up leaves its note and Continue lands on the report with the panel open; no button where there is no connector`)
+console.log(`ask-ai-render-check: the header, both panels and the unmeasured state render; the panel carries its caret and the button is drawn open, and a finding's own button opens and shuts it; all four questions reach the link typed in; Set it up leaves its note and Continue lands on the report with the panel open; no button where there is no connector`)
 if (shotsDir) console.log(`ask-ai-render-check: shots in ${shotsDir}`)

package/scripts/authority-boundary-probe.mjs

@@ -28,18 +28,18 @@ import { join } from "node:path";
 import { driverDir, ensureDriverDir } from "../shared/driver-dir.mjs";   // — one definition of where `_driver/` is
 import { tmpdir } from "node:os";
 import { buildClaudeArgs, spawnEnv } from "../driver/engine/anthropic-agent.mjs";
-import { envFrom } from "../shared/env-aliases.mjs";   // — resolves EITHER spelling; names the retired one because that is the live-writable half
+import { resolveEngineProgram } from "../driver/driver.config.mjs";   // — the program a run would spawn, found the way a run finds it
 
 const arg = (f, d) => { const i = process.argv.indexOf(f); return i > 0 ? process.argv[i + 1] : d; };
 const model = arg("--model", "claude-sonnet-5");
 
 const root = mkdtempSync(join(tmpdir(), "authority-probe-"));
 const skills = join(root, "skills"), runDir = join(root, "run");
-mkdirSync(join(skills, "prelim-register"), { recursive: true });
+mkdirSync(join(skills, "clearance-register"), { recursive: true });
 ensureDriverDir(runDir);
-writeFileSync(join(skills, "prelim-register", "SKILL.md"), "# doctrine\nThe method for this stage.\n");
-const doctrine = join(skills, "prelim-register", "NOTES.md");   // the incident's shape: a NEW file in the doctrine tree
-const existing = join(skills, "prelim-register", "SKILL.md");   // already on disk — the Edit target
+writeFileSync(join(skills, "clearance-register", "SKILL.md"), "# doctrine\nThe method for this stage.\n");
+const doctrine = join(skills, "clearance-register", "NOTES.md");   // the incident's shape: a NEW file in the doctrine tree
+const existing = join(skills, "clearance-register", "SKILL.md");   // already on disk — the Edit target
 const record = driverDir(runDir, "probe-note.json");       // the forensic record a seat must never author
 const output = join(runDir, "findings.json");                   // where this seat's own output belongs
 
@@ -73,7 +73,9 @@ console.log(`probe root: ${root}`);
 console.log(`--add-dir roots: ${args.filter((a, i) => args[i - 1] === "--add-dir").join(", ")}`);
 console.log(`--settings present: ${args.includes("--settings")}`);
 
-const child = spawn(envFrom(process.env, "CLEAROTRON_CLAUDE_PATH") || "claude", [...args, "--include-hook-events"],
+// The program a run would spawn (driver.config.mjs resolveEngineProgram), so this probes the same copy.
+const program = resolveEngineProgram("anthropic-agent");
+const child = spawn(program.resolved ?? program.bin, [...args, "--include-hook-events"],
   { stdio: ["pipe", "pipe", "pipe"], cwd: runDir, env: spawnEnv() });
 let out = "", err = "";
 child.stdout.on("data", (d) => { out += d; });

package/scripts/backfill-started-at.mjs

@@ -28,7 +28,7 @@
 import "../shared/env-local.mjs";   // — FIRST: applies the CLEAROTRON_* translation before any module-top
 // capture evaluates. Reads no `.env` here — that load is gated on isCliEntry(argv[1]).
 import { readdirSync, readFileSync, writeFileSync, renameSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { join } from "node:path"; import { studioDirFor } from "../shared/pre-rename-spellings.mjs";
 import { DRIVER_DIR, driverDir } from "../shared/driver-dir.mjs";   //
 
 // NAMED, never guessed. This used to fall back to a hardcoded production workspace path, so a run
@@ -115,7 +115,7 @@ function main() {
   const counts = {};
   const rows = [];
   for (const agent of AGENTS) {
-    const studio = join(WORKSPACE_ROOT, `workspace-${agent}`, "studio", "prelim-search");
+    const studio = studioDirFor(join(WORKSPACE_ROOT, `workspace-${agent}`));
     if (!existsSync(studio)) continue;
     for (const runDir of findRunDirs(studio)) {
       const r = backfillRun(runDir, { apply: APPLY });

package/scripts/census-merge-driver.mjs

@@ -37,11 +37,24 @@
 // driver removes a conflict; it does not remove the check. That is the whole safety argument, and if
 // that arm is ever weakened this file becomes unsafe with it.
 //
-// ── WHAT IT STILL REFUSES ───────────────────────────────────────────────────────────────────────────
+// ── WHAT IT STILL REFUSES, AND HOW IT REFUSES ───────────────────────────────────────────────────────
 //
 // Both sides changing the SAME file's counts to DIFFERENT values is a real disagreement — two branches
 // edited one test file — and it exits non-zero so git raises the conflict a human should see. A driver
 // that silently picked a side there would be the "matches neither tree" failure in a new costume.
+//
+// AND IT WRITES MARKERS, BECAUSE EXITING WITHOUT WRITING IS NOT A REFUSAL. Until 2026-09-18 the refusal
+// path wrote nothing at all, which leaves `%A` holding the OURS side untouched: a file with no conflict
+// markers that parses as valid JSON, beside git's own "CONFLICT (content)" line. Both cheap checks a
+// person runs on a conflicted file — does it have markers, does it parse — passed, so it was staged
+// blind, and every entry the union had taken from THEIRS went with it. Measured that day on a real
+// merge: the result was byte-identical to ours, and one test file's entry was simply gone. A census that
+// under-counts is a population floor reading low, which is the one failure the census exists to prevent.
+//
+// So a refusal now writes a file that CANNOT be staged blind: real markers at column 0, the named
+// disagreements above them, the UNION on the ours side — so a reader who resolves by taking it keeps
+// every entry this driver could merge — and theirs whole on the other. It parses as nothing, which is
+// the honest direction for a file nobody has resolved yet.
 
 import { readFileSync, writeFileSync } from "node:fs";
 
@@ -139,9 +152,27 @@ const merged = {
 };
 
 if (conflicts.length) {
+  const named = conflicts.slice(0, 10).map((c) => `  ${c}`);
+  const more = conflicts.length > named.length ? [`  …and ${conflicts.length - named.length} more`] : [];
   console.error(`census-merge-driver: ${conflicts.length} entr(y/ies) changed on BOTH sides — not ours to pick:`);
-  for (const c of conflicts.slice(0, 10)) console.error(`  ${c}`);
+  for (const line of [...named, ...more]) console.error(line);
   console.error("  Resolve by hand, or re-run `node scripts/mint-suite-census.mjs --apply` on the merged tree.");
+
+  // THE UNION RIDES THE OURS SIDE, and that is the point of writing at all. Everything this driver COULD
+  // merge is in it — including every entry that exists only on theirs — so resolving by taking this side
+  // loses nothing but the disagreements, which are named above it and are the only thing a human is
+  // being asked about.
+  writeFileSync(oursPath, [
+    `census-merge-driver: ${conflicts.length} entr(y/ies) changed on BOTH sides and were NOT merged.`,
+    ...named, ...more,
+    "Resolve, delete these lines and the markers, then run `node scripts/mint-suite-census.mjs --apply`.",
+    "<<<<<<< ours — the union of both sides, except the entries named above",
+    JSON.stringify(merged, null, 2),
+    "=======",
+    JSON.stringify(theirs, null, 2),
+    ">>>>>>> theirs",
+    "",
+  ].join("\n"));
   process.exit(1);
 }
 

package/scripts/citation-anchor-report.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026 Cordillera Sarl. Additional terms under section 7 of the AGPL-3.0 apply — see ADDITIONAL-TERMS.md
+// WHICH BARE CITATIONS COULD CARRY A SYMBOL, AND WHICH ONES DISAGREE WITH THEIR OWN PROSE.
+//
+//   node scripts/citation-anchor-report.mjs           the report
+//   node scripts/citation-anchor-report.mjs --list    every row, not the first ten of each kind
+//
+// ── WHY THIS REPORTS AND DOES NOT REWRITE ────────────────────────────────────
+//
+// citation-line-check states its own blindness: it cannot see a citation pointing at the WRONG LIVE LINE
+// while that line is real code, and it says the fix is to cite the symbol. The obvious next step is a
+// codemod — the line is known and the file is known, so read the enclosing symbol out of the file and
+// append it. Measured before building, that is the wrong move, and the measurement is worth keeping
+// beside the thing it refutes.
+//
+// A codemod reads where the number CURRENTLY POINTS and writes that down. It cannot tell a citation that
+// is right from one that has drifted, because both point somewhere, and appending the destination makes
+// either self-consistent. Driven against the two citations a hand audit had already proved wrong:
+//
+//   verify.mjs line 1539   would gain the name coverageEntryList — and the line is still
+//                    `entries.push(e);` and the token it claims to site is minted three other places.
+//   stages.mjs line 844    would gain the name inputsForReference — and the line is still a comment,
+//                    and that citation carries `[citation unverified]` today, which is a reader having
+//                    doubted it. The rewrite strips the doubt and leaves a green tick.
+//
+// So the mechanism turns roughly a hundred unverifiable citations into verified-looking ones. This script
+// produces the same information as a WORKLIST instead, and changes nothing.
+//
+// ── WHAT IT MEASURES, AND THE TWO RULES THAT ARE NOT OBVIOUS ────────────────
+//
+// THE ANCHOR IS THE TOP-LEVEL DECLARATION, NOT THE INNERMOST ONE. The innermost is the literal reading of
+// "the symbol enclosing that line" and it is wrong here: measured over this tree it names a local or a
+// one-to-three-letter binding 29 times — `e`, `hit`, `ob`, `one`, `out`, `known`, `unplaced` — against 2
+// for the top-level rule, over the same 115 citations. An anchor nobody would have written by hand is not
+// an anchor; it is the number wearing a name.
+//
+// A CITATION POINTING INSIDE A FUNCTION IT NAMES IS CORRECT, and the innermost rule reports it as a
+// disagreement. Two of this report's first six "confirmed" rows were that bug rather than a bad citation:
+// publish-inputs.mjs cites line 65 of mcp-server/lib/coverage.mjs and names `assertValidatorCoverage`, declared at
+// 63, which is exactly right. The rule below is why they no longer appear.
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { corpusOf, citationsIn, indexByBasename } from "./citation-line-check.mjs";
+import { isEntrypoint } from "../shared/is-entrypoint.mjs";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+// The gate's own matchers, restated here rather than imported because they are not exported: keeping them
+// identical is the property, so any drift between the two is a defect in this file and not in the gate.
+const ANY_DECL = /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|const|let|var|class)\s+[A-Za-z_$]/;
+const NAME_OF = /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|const|let|var|class)\s+([A-Za-z_$][\w$]*)/;
+const INDENT_OF = (l) => (String(l).match(/^[ \t]*/) || [""])[0].length;
+
+/**
+ * The top-level declaration whose span contains `line`, or null when the line is not in code at all.
+ * The span ends at the next top-level declaration, which is constructRange's sibling rule at indent 0.
+ * PURE.
+ */
+export function topLevelAnchor(lines, line) {
+  let best = null;
+  for (let d = 0; d < lines.length; d++) {
+    if (!ANY_DECL.test(lines[d]) || INDENT_OF(lines[d]) !== 0) continue;
+    const name = (lines[d].match(NAME_OF) || [])[1];
+    if (!name) continue;
+    let end = d + 1;
+    while (end < lines.length && !(ANY_DECL.test(lines[end]) && INDENT_OF(lines[end]) === 0)) end++;
+    if (line >= d + 1 && line <= end && (!best || d + 1 > best.declaredAt)) best = { name, declaredAt: d + 1, end };
+  }
+  return best;
+}
+
+/**
+ * The identifiers the citing line CLAIMS, which is not every word in it. Only a backticked span or a name
+ * shaped like code counts — camelCase, SCREAMING_SNAKE, or a `$`/`_` in it.
+ *
+ * MEASURED, NOT ASSUMED: taking every word put "spec", "one", "model", "skills" and "config" forward as
+ * identifier claims, because each is also declared somewhere in some cited file, and the drifted count
+ * went from a handful to 120. A report whose worklist is mostly English words is a worklist nobody reads.
+ * Longest first, so a suffix never shadows its owner.
+ */
+const namesIn = (sentence) => {
+  const s = String(sentence);
+  const ticked = [...s.matchAll(/`([A-Za-z_$][\w$]*)`/g)].map((m) => m[1]);
+  const shaped = [...s.matchAll(/[A-Za-z_$][\w$]{2,}/g)].map((m) => m[0])
+    .filter((n) => /[a-z][A-Z]/.test(n) || /^[A-Z0-9_]{3,}$/.test(n) || /[_$]/.test(n));
+  return [...new Set([...ticked, ...shaped])].sort((a, b) => b.length - a.length);
+};
+
+/**
+ * One row per bare citation whose target sits in code. PURE given its readers.
+ *
+ * `verdict` is one of:
+ *   corroborated  the citing prose names the anchor — safe to append, and the only class that is
+ *   silent        the prose names no identifier at all, so there is nothing to check the anchor against
+ *   disagrees     the prose names something else that is NOT declared in the cited file — weak evidence,
+ *                 because it is usually a caller or a type rather than a claim about this file
+ *   drifted       the prose names something DECLARED ELSEWHERE in the cited file, and the citation does
+ *                 not point inside it. That is the shape of a number that moved.
+ */
+export function anchorRows(citations, linesOf) {
+  const rows = [];
+  for (const c of citations) {
+    if (c.symbols?.length) continue;                       // already checkable
+    const target = linesOf(c.path ?? c.cited);
+    if (!target) continue;
+    const anchor = topLevelAnchor(target, c.start);
+    if (!anchor) { rows.push({ ...c, verdict: "no-code", anchor: null }); continue; }
+    const prose = namesIn(linesOf(c.from)?.[c.atLine - 1] ?? "");
+    if (prose.includes(anchor.name)) { rows.push({ ...c, verdict: "corroborated", anchor }); continue; }
+    const others = prose.filter((n) => n !== anchor.name);
+    if (!others.length) { rows.push({ ...c, verdict: "silent", anchor }); continue; }
+    let elsewhere = null;
+    for (const n of others) {
+      const decl = new RegExp(`^\\s*(?:export\\s+)?(?:default\\s+)?(?:async\\s+)?(?:function|const|let|var|class)\\s+${n.replace(/\$/g, "\\$")}\\b`);
+      for (let i = 0; i < target.length; i++) {
+        if (!decl.test(target[i])) continue;
+        // THE CITATION POINTING INSIDE WHAT IT NAMES IS CORRECT, not drifted — see the header.
+        const span = topLevelAnchor(target, i + 1);
+        if (span && c.start >= span.declaredAt && c.start <= span.end) { elsewhere = null; i = target.length; n; break; }
+        elsewhere = { name: n, declaredAt: i + 1 };
+        break;
+      }
+      if (elsewhere) break;
+    }
+    rows.push({ ...c, verdict: elsewhere ? "drifted" : "disagrees", anchor, elsewhere });
+  }
+  return rows;
+}
+
+function main() {
+  const loaded = corpusOf(ROOT);
+  if (loaded == null) {
+    console.log("citation-anchor-report did not run — no tracked corpus. This is a SKIP, not a pass.");
+    process.exit(0);
+  }
+  const { files, corpus } = loaded;
+  const text = new Map(corpus.map((c) => [c.file, c.text.split("\n")]));
+  const linesOf = (p) => {
+    if (text.has(p)) return text.get(p);
+    try { const l = readFileSync(join(ROOT, p), "utf8").split("\n"); text.set(p, l); return l; } catch { return null; }
+  };
+  const citations = citationsIn(corpus, indexByBasename(files));
+  const bare = citations.filter((c) => !c.symbols?.length);
+  const rows = anchorRows(citations, linesOf);
+  const by = (v) => rows.filter((r) => r.verdict === v);
+  const all = process.argv.includes("--list");
+  const show = (v) => (all ? by(v) : by(v).slice(0, 10));
+
+  console.log(`citation-anchor-report — ${citations.length} citation(s), ${citations.length - bare.length} already name a symbol, ${bare.length} BARE`);
+  console.log(`  ${by("no-code").length} of the bare point at prose, comments, skill documents or data — there is NO symbol to cite,`);
+  console.log("      and the gate's own advice cannot be followed on them. That is a guard-design question, not a chore.");
+  console.log(`  ${rows.length - by("no-code").length} point at a line inside code:`);
+  console.log(`      corroborated  ${by("corroborated").length}  the citing prose names the enclosing symbol — appending it is safe`);
+  console.log(`      drifted       ${by("drifted").length}  the prose names something declared ELSEWHERE in the cited file`);
+  console.log(`      disagrees     ${by("disagrees").length}  the prose names something not declared there — usually a caller, weak evidence`);
+  console.log(`      silent        ${by("silent").length}  the prose names nothing to check the anchor against`);
+
+  if (by("drifted").length) {
+    console.log("\nDRIFTED — read these first. Each names a symbol this file declares somewhere the citation does not point:");
+    for (const r of show("drifted")) {
+      console.log(`  ${r.from}:${r.atLine}`);
+      console.log(`     cites ${r.cited}:${r.start}, which is inside ${r.anchor.name}`);
+      console.log(`     names ${r.elsewhere.name}, declared at ${r.elsewhere.declaredAt}`);
+    }
+  }
+  if (by("corroborated").length) {
+    console.log("\nCORROBORATED — the anchor can be appended by hand with the prose as the check:");
+    for (const r of show("corroborated")) console.log(`  ${r.from}:${r.atLine}  ${r.cited}:${r.start} → ${r.anchor.name}`);
+  }
+  if (!all && (by("drifted").length > 10 || by("corroborated").length > 10)) console.log("\n  (--list for every row)");
+
+  // A REPORT EXITS 0. Its `drifted` class is evidence for a person, not a decidable defect: the prose can
+  // name a symbol for a reason the citation is not about, and this file's own header records two rows it
+  // got wrong before the rule was fixed. A worklist that fails a build teaches people to silence it.
+  console.log("\nThis is a worklist, not a gate — it exits 0 on every finding. citation-line-check is the gate.");
+  process.exit(0);
+}
+
+if (isEntrypoint(import.meta.url)) main();

package/scripts/dead-names.mjs

@@ -47,7 +47,7 @@ export const GUARD = "dead-names (#853)";
 // agent identities for individuals at this firm, shipped in an operator script's default roster, in a
 // systemd unit watching their queues, and in two test fixtures. That out-of-scope note ruled `alex`
 // and `sam` INVENTED, which is why those stay; these two were never covered by that ruling.
-export const DEAD_NAME_RE = /lorestar|lore_(pool|url|flags)|prelim_lore|lorectl|loreurl|lorecontrols|trademark-lore|\blore\b|\baughra|clawdi-(lisa|lidia)/i;
+export const DEAD_NAME_RE = /lorestar|lore_(pool|url|flags)|clearance_lore|lorectl|loreurl|lorecontrols|trademark-lore|\blore\b|\baughra|clawdi-(lisa|lidia)/i;
 
 /**
  * Where a true match is somebody else's word rather than our dead name. NAMED, with the reason, and

package/scripts/deprecate-below.mjs

@@ -78,6 +78,43 @@ function published() {
   return Array.isArray(versions) ? versions : [versions];
 }
 
+/** How long to keep asking the registry to show a write it has already accepted. */
+export const CONFIRM_BUDGET_MS = 90_000;
+const CONFIRM_STEP_MS = 3_000;
+
+/**
+ * Confirm writes the registry has ACCEPTED but may not be serving yet.
+ *
+ * WHY THIS IS A SECOND PASS AND NOT A READ AFTER EACH WRITE. `npm deprecate` returns when the registry
+ * has taken the write, not when every reader can see it. Reading back one line later asks a question
+ * the registry has not finished answering, and on 2026-09-17 that reported ELEVEN successful
+ * deprecations as failures — run 35219705516, where the messages were all in place minutes later and
+ * the job had already exited 1. The outside read was the truth and the job's red was not evidence.
+ *
+ * SO THE WRITES GO FIRST AND THE READING COMES AFTER, which also collapses a per-version read into one
+ * pass over what is left. Anything still unseen is asked for again until the budget runs out.
+ *
+ * A WRITE THAT WAS ACCEPTED AND IS NOT YET VISIBLE IS NOT A FAILED WRITE, and the caller is told so in
+ * those words rather than having the two folded together. `npm deprecate` exiting 0 is what says the
+ * write happened; this pass says whether the registry is serving it yet.
+ */
+export async function confirmWrites({ versions, read, sleep, now = () => Date.now(),
+                                      budgetMs = CONFIRM_BUDGET_MS, stepMs = CONFIRM_STEP_MS }) {
+  const pending = new Set(versions);
+  const confirmed = [];
+  const started = now();
+  while (pending.size) {
+    for (const v of [...pending]) {
+      let msg = null;
+      try { msg = read(v); } catch { msg = null; }   // a read that threw is asked again, not judged
+      if (msg) { confirmed.push(v); pending.delete(v); }
+    }
+    if (!pending.size || now() - started >= budgetMs) break;
+    await sleep(stepMs);
+  }
+  return { confirmed, unconfirmed: [...pending], waitedMs: now() - started };
+}
+
 /** One version's deprecation message, read by its own exact spec. Null when it carries none. */
 function deprecationOf(version) {
   // `--json` on a field that is absent prints nothing at all, which JSON.parse refuses. An empty read is
@@ -89,7 +126,7 @@ function deprecationOf(version) {
   return typeof v === "string" && v.trim() ? v : null;
 }
 
-function main() {
+async function main() {
   const argv = process.argv.slice(2);
   const at = (flag) => { const i = argv.indexOf(flag); return i >= 0 ? argv[i + 1] : null; };
   const DRY = argv.includes("--dry-run");
@@ -115,6 +152,7 @@ function main() {
   console.log(`deprecate-below: ${all.length} published version(s); ${candidates.length} below ${below}.`);
 
   let done = 0, skipped = 0, failed = 0;
+  const wrote = [];
   for (const v of candidates) {
     let existing;
     try { existing = deprecationOf(v); }
@@ -132,15 +170,35 @@ function main() {
       failed += 1;
       continue;
     }
-    // READ BACK, PER VERSION, and report what the registry says rather than that the command exited 0.
-    let now = null;
-    try { now = deprecationOf(v); } catch { now = null; }
-    if (now) { console.log(`  ${v}: deprecated — registry reads back "${now.slice(0, 60)}"`); done += 1; }
-    else { console.error(`  ${v}: deprecate reported success and the registry reads back NOTHING.`); failed += 1; }
+    // ACCEPTED. Whether the registry is SERVING it yet is asked once, after every write, below.
+    console.log(`  ${v}: deprecate accepted`);
+    wrote.push(v);
+  }
+
+  // ── NOW ASK WHETHER THE REGISTRY IS SERVING THEM ────────────────────────────────────────────────
+  let confirmed = [], unconfirmed = [], waitedMs = 0;
+  if (wrote.length && !DRY) {
+    ({ confirmed, unconfirmed, waitedMs } = await confirmWrites({
+      versions: wrote,
+      read: (v) => deprecationOf(v),
+      sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    }));
+    done += confirmed.length;
+    for (const v of confirmed) console.log(`  ${v}: serving the message`);
+    for (const v of unconfirmed) {
+      console.error(`  ${v}: WRITE ACCEPTED, not yet served after ${Math.round(waitedMs / 1000)}s — `
+        + "the registry took it and is not showing it yet. Read the version from outside before treating "
+        + "this as undone; re-running is safe and will report it as already deprecated.");
+    }
+  } else if (DRY) {
+    done += wrote.length;
   }
 
-  console.log(`deprecate-below: ${done} deprecated, ${skipped} already carried a message, ${failed} failed.`);
+  console.log(`deprecate-below: ${done} deprecated, ${skipped} already carried a message, `
+    + `${unconfirmed.length} accepted but not yet served, ${failed} failed.`);
+  // ONLY A FAILED WRITE IS A FAILURE. A write the registry accepted and has not caught up on is not a
+  // release gone wrong, and exiting 1 for it is what turned eleven successful deprecations into a red.
   return failed ? 1 : 0;
 }
 
-if (process.argv[1] && process.argv[1].endsWith("deprecate-below.mjs")) process.exit(main());
+if (process.argv[1] && process.argv[1].endsWith("deprecate-below.mjs")) process.exit(await main());

package/scripts/drain-preflight.mjs

@@ -108,7 +108,7 @@ export function backlogFinding(backlog, dir, stuckAfterSec = STUCK_AFTER_SEC) {
  * The queue directories a `.path` unit actually watches, with `%h` resolved.
  *
  * COMMENTED LINES ARE NOT WATCHES, and that matters here more than usual: the headless glob
- * (`%h/prelim-queue/*.json`) ships commented out, so a standalone deployment that never uncommented it
+ * (`%h/clearance-queue/*.json`) ships commented out, so a standalone deployment that never uncommented it
  * has event-driven pickup dead on the one queue it uses. Reading the file without honouring `#` would
  * report that box as watched.
  *