clearotron 0.3.2 → 0.3.3-beta.0

package/providers/clarivate/src/core.js

@@ -90,6 +90,9 @@ export async function clarivateFetch(apiKey, base, path, { body = null, method =
       attempts = i + 1;
       resp = await fetch(url, init);
       if (resp.ok || resp.status < 500 || i === retries) break;
+      // A 500 wrapping the search service's 400 is a refusal of the query as written, not weather: the
+      // same request is refused the same way, so it is not sent again (countFailureReason below).
+      if (WRAPPED_REFUSAL.test(await resp.clone().text().catch(() => ""))) break;
       await new Promise((r) => setTimeout(r, 1500 * (i + 1)));
     }
   } catch (err) {
@@ -1113,13 +1116,45 @@ export async function doSearch(apiKey, base, params, tctx) {
 }
 
 // ── Count ─────────────────────────────────────────────────────────────────────────────────────────
-// POST /count takes the SAME SearchRequest body as /search, is cheap, works at ANY magnitude (209012
-// returned without complaint) and returns PER-OFFICE counts in one call. This is the enumerate
+// POST /count takes the SAME SearchRequest body as /search, is cheap, works at ANY magnitude and
+// returns PER-OFFICE counts in one call. This is the enumerate
 // kernel's countProbe:"endpoint" dependency, so it returns the kernel's plain probe shape
 // { ok, total, reason } — plus `per_office`, which is richer than corsearch can offer and rides into
 // the crowd descriptor for judgment.
 
 /** ONE /count round trip over already-resolved params. Returns the kernel's plain probe shape. */
+// ── A REFUSED QUERY IS NAMED AS ONE, with the size of what was sent ─────────────────────────────────
+//
+// The vendor answers a query its search service cannot take with that service's 400, delivered inside
+// its own 500: `INTERNAL_SERVER_ERROR - 400 on POST request for "…/search"`. Passed on as a bare HTTP 500
+// it reads as an outage and names nothing an operator can act on. A query that is too wide is the common
+// case: the service's bound is the number of OR terms in one field, which is about 496, not the query's
+// length.
+// The reason says so: the widest OR stack's term count and characters, and this provider's declared
+// width. It avoids the words `HTTP 400`, which providerRejectedTheQuery reads as a cue to retry an owner
+// stack on the caller's own term; that behaviour is unchanged.
+//
+// AND IT IS A CAPABILITY GAP. The service refused the query as written and will refuse the identical query
+// every time, so the reason carries CAPABILITY_GAP_MARKER: the plan executor defers the slice as a
+// disclosed gap at once, as it does a query buildSearchRequest refuses before sending, instead of sending
+// it round the recovery ladder. On production that ladder re-sent a refused 500-term query and spent a
+// recovery park each time. Every other HTTP failure keeps the transient reading.
+const WRAPPED_REFUSAL = /\b400\s+on\s+POST\s+request\b/;
+const widestOrStack = (body) => (body?.searchFields ?? []).reduce((best, f) => {
+  const v = String(f?.value ?? "");
+  const terms = v ? v.split(" OR ").length : 0;
+  return terms > best.terms ? { terms, chars: v.length } : best;
+}, { terms: 0, chars: 0 });
+export function countFailureReason(status, words, body) {
+  if (status !== 500 || !WRAPPED_REFUSAL.test(String(words ?? ""))) return `HTTP ${status}${words ? `: ${words}` : ""}`;
+  const w = widestOrStack(body);
+  // THE NUMBERS COME LAST. The executor clips a failed slice's reason to its head and tail, and its own
+  // prefixes fill the head, so a count placed early is elided; the tail is what a run's record keeps.
+  return `${CAPABILITY_GAP_MARKER} register_refused_query: the register refused this query as malformed (a 400 inside its `
+    + `HTTP 500). Provider's words: ${words}. Sent ${w.terms} OR terms (${w.chars} characters); this provider's declared `
+    + `width is ${CAPABILITIES.maxOrWidth} terms.`;
+}
+
 async function countOnce(apiKey, base, p, tctx) {
   let body;
   try { body = buildSearchRequest(p); }
@@ -1129,11 +1164,12 @@ async function countOnce(apiKey, base, p, tctx) {
   // Marked as a capability gap so the plan executor DEFERS the slice — a disclosed coverage row the
   // lawyer reads — instead of stamping a transient error and grinding the whole run to a fan-in
   // StageFailure over an answer that will never differ. A real HTTP failure below keeps the transient
-  // reading and rides the repair ladder, exactly as before.
+  // reading and rides the repair ladder, exactly as before, except a query the service refused as written
+  // (countFailureReason above).
   catch (e) { return { ok: false, total: null, per_office: null, reason: `${CAPABILITY_GAP_MARKER} ${e.message}` }; }
 
   const r = await clarivateFetch(apiKey, base, "/count", { body, tctx: { ...tctx, target: String(echoOf(p)).slice(0, 200) } });
-  if (!r.ok) return { ok: false, total: null, per_office: null, reason: `HTTP ${r.status}${errText(r) ? `: ${errText(r)}` : ""}` };
+  if (!r.ok) return { ok: false, total: null, per_office: null, reason: countFailureReason(r.status, errText(r), body) };
   // Named rather than folded into the "no counts{}" branch below: both refuse (total null, never 0),
   // but someone repairing a run needs to know the response was CUT, not that the provider answered in
   // a shape we did not expect.
@@ -1734,7 +1770,7 @@ export async function doEnumerate(apiKey, base, params, tctx) {
 //     dictated a count instead of an enumerate. POST /search FAILS LOUD past 30000 (tooManyResults),
 //     so routing the count probe through it would return an ERROR string, the executor would stamp the
 //     block error:true, and a SANCTIONED CROWD would be counted MISSING — doctrine 5 inverted. POST
-//     /count never fails on magnitude (209012 returned without complaint) and carries per-office truth.
+//     /count never fails on magnitude and carries per-office truth.
 //     `countParams` is therefore {}: buildSearchRequest has no `limit` knob to honour, and passing a
 //     dead parameter would only imply one exists.
 //

package/providers/corsearch/src/capabilities.js

@@ -133,6 +133,10 @@ export const CAPABILITIES = Object.freeze({
   // Several goods terms become several `product:` clauses, and within one field this query language
   // ORs them implicitly — the same "any of these words" the explicit OR writes elsewhere.
   goodsTextListOr: true,
+  // The shortest term the contains form accepts: none known, so none declared. The vendor publishes no
+  // public reference for this API (none was found on 2026-09-22), and no short-term refusal has been
+  // measured here. `null` keeps the contains form at every length; see clarivate/capabilities.js.
+  containsMinLength: null,
   // ── WHICH FORM OF A NON-LATIN MARK DOES THE INDEX HOLD? ──────────────────────────────────────────
   // `true` = the CHARACTERS. A native-script term is a legitimate, productive query here and MUST be
   // sent — the shared executor's script-form refusal (providers/_shared/script-form.mjs) is switched

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "trademark-oauth-mcp-bridge",
-  "version": "0.3.2",
+  "version": "0.3.3-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/providers/signa/src/capabilities.js

@@ -154,6 +154,23 @@ export const CAPABILITIES = Object.freeze({
   // So the compiler does not build a multi-term goods entry for this provider, and it must never fall
   // back to a space-joined string. No coverage is lost: the broad class-wide sweep still runs.
   goodsTextListOr: false,
+  // ── THE SHORTEST TERM THE CONTAINS FORM ACCEPTS: 3 folded characters, documented ────────────────
+  //
+  // Signa's API reference, "Search trademarks", section "Match modes" (docs.signa.so/api-reference/
+  // trademarks/search-trademarks, read 2026-09-22): "Deterministic modes accept a single-character `q`
+  // (one non-empty folded char), whereas `similar` requires at least 2 folded chars and `contains`
+  // requires at least 3." The same page's validation rules repeat it. A shorter term on `contains` is a
+  // hard 400 ("match=contains requires q to be at least 3 characters (after case/accent folding) to
+  // avoid an over-broad substring scan").
+  //
+  // The compiler reads this: a goods-narrowed question or a saturation probe whose term is shorter is
+  // asked on the exact form instead, with the same class and goods filters, and the plan entry says so.
+  // Exact goes out as the ranked `strategies: ["exact"]`, which `similar`'s 2-character floor governs,
+  // so a two-letter mark is answered; a one-letter mark is below both floors and stays refused.
+  containsMinLength: 3,
+  // The ranked shape's floor: "`similar` requires at least 2 folded chars" (same page). An exact question
+  // shorter than this goes out on the deterministic `match`, which takes one; from here up it stays ranked.
+  rankedMinLength: 2,
   // Search rows already carry status / nice_classes / owner_name → screening is inline, zero extra calls.
   screenSource: "search-row",
   // No hard result ceiling, and no total to compare one against.
@@ -168,8 +185,6 @@ export const CAPABILITIES = Object.freeze({
   //
   //   strategies[]  exact | phonetic | fuzzy | prefix                        — ranked, several per call
   //   match         similar | exact | starts_with | ends_with | contains     — deterministic, one only
-  //
-  // Every value below was run against the live API with the resulting total recorded.
   predicates: Object.freeze({
     exact:          "exact",        // strategies[] — the deterministic shape, the ranked one for audit continuity
     // `contains` IS the unanchored mode this contract said did not exist. The old header
@@ -177,12 +192,11 @@ export const CAPABILITIES = Object.freeze({
     // contains slice is a substring sweep, and they return different sets. It never needed to be
     // fuzzy; it needed the deterministic shape, which nothing here had.
     //
-    // ONE LIVE CONSTRAINT NOT IN THE PUBLISHED SPECIFICATION: deterministic modes take a
-    // query of 1 character or more. `contains` in fact demands THREE — "match=contains requires q to
-    // be at least 3 characters (after case/accent folding) to avoid an over-broad substring scan."
-    // A one- or two-character element therefore cannot ride this predicate, and it fails loud (400)
-    // rather than quietly returning a narrower set. Recorded because it is the second place in this
-    // file where the document and the wire disagree, and the wire is the one that answers queries.
+    // A LENGTH FLOOR THE VENDOR DOCUMENTS: deterministic modes take a query of 1 character or more,
+    // and `contains` demands THREE — "match=contains requires q to be at least 3 characters (after
+    // case/accent folding) to avoid an over-broad substring scan." A one- or two-character element
+    // therefore cannot ride this predicate, and it fails loud (400) rather than quietly returning a
+    // narrower set. `containsMinLength` above declares it, and the compiler asks such a term exactly.
     default:        "contains",
     // `starts_with`, NOT the `prefix` strategy. Both exist and the executor uses this one:
     // planPredicateParams emits `match_mode: "starts_with"` for a trailing-`*` entry and never emits

package/providers/signa/src/core.js

@@ -30,6 +30,9 @@ import { nonAnswerBodyError, parseJsonBody, unparsedBodyError } from "../../_sha
 import { makeEnumerate, isOwnerScoped } from "../../_shared/enumerate.mjs";
 import { makeExecutePlan } from "../../_shared/execute-plan.mjs";
 import CAPABILITIES, { SIGNA_OFFICE_KEYS, OWNER_SCOPED_WINDOW } from "./capabilities.js";
+// The register's own measure of a term's length: case and accents folded, spaces not counted — the same
+// measure its documented floors are stated in (the compiler's foldedTermLength counts the same way).
+const foldedLength = (q) => [...String(q ?? "").normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/\s+/g, "")].length;
 import { SIGNA_OFFICE_SNAPSHOT } from "./offices.generated.js";
 
 export const DEFAULT_BASE = "https://api.signa.so";
@@ -660,8 +663,16 @@ export function toSignaParams(p = {}) {
   // `match`. exact/phonetic stay on strategies, which is what this provider has always sent and what
   // its fixtures were captured with; the anchored and unanchored modes can only be expressed by
   // `match`, so they select that shape and drop strategies.
+  //
+  // EXACT BELOW THE RANKED FLOOR ONLY. The ranked shape takes `similar`'s floor of two folded
+  // characters, so a one-letter exact question is refused there. The deterministic `match: "exact"`
+  // takes one, but it asks a narrower question: "`exact` requires the whole mark to equal `q`", where
+  // the ranked `exact` strategy also returns longer marks that contain the term, which is the recall an
+  // identical question relies on. So exact stays ranked from the floor up, and only a term below it
+  // goes deterministic, where it is answered rather than refused.
   const mode = String(p.match_mode ?? "").trim();
-  if (mode === "exact" || mode === "phonetic" || mode === "prefix") out.strategies = [mode];
+  if (mode === "exact" && foldedLength(out.query) < CAPABILITIES.rankedMinLength) out.match = "exact";
+  else if (mode === "exact" || mode === "phonetic" || mode === "prefix") out.strategies = [mode];
   else if (mode === "starts_with" || mode === "ends_with" || mode === "contains") out.match = mode;
   // ── `default` IS THE COUNT LANE'S WORD FOR THE SAME UNANCHORED QUERY THE PLAN LANE CALLS `{}` ────
   //

package/scripts/demo-evidence.mjs

@@ -0,0 +1,114 @@
+#!/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
+// demo-evidence.mjs — THE HAND-WRITTEN DIFF MUST BE REVIEWABLE ON ITS OWN.
+//
+// One integration branch carried 37 commits, 2,490 files, 221,105 additions and 410,984 deletions, and
+// most of it was regenerated demo evidence. A reviewer cannot find the source changes inside that, so
+// in practice nobody reads them — the review happens, and it reviews nothing. The evidence is not the
+// problem: it is generated output, it is meant to change wholesale, and it is right that it ships.
+// Mixing it into the same commits as hand-written code is the problem.
+//
+// TWO HALVES, because a convention nobody checks is a convention that lasts one beta:
+//
+//   --check    a commit that touches `demo/` touches nothing else, across a range
+//   --apply    re-record `demo/MANIFEST.json` — generator, tree, and the run each product replays
+//
+// The manifest is what makes the regeneration commit self-explaining: without it a reviewer skipping
+// the demo diff is taking on trust that it IS regenerated output rather than a hand edit hidden in
+// 200,000 lines. With it, the thing they are skipping says what produced it.
+
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+export const MANIFEST = join(ROOT, "demo", "MANIFEST.json");
+export const GENERATOR = "scripts/freeze-example-run.mjs";
+
+const git = (...args) => execFileSync("git", args, { cwd: ROOT, encoding: "utf8" }).trim();
+
+/** Every product directory under `demo/`, with the run it replays. */
+export function products({ root = ROOT } = {}) {
+  const dir = join(root, "demo");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => statSync(join(dir, name)).isDirectory())
+    .sort()
+    .map((name) => {
+      let meta = {};
+      try { meta = JSON.parse(readFileSync(join(dir, name, "meta.json"), "utf8")); } catch { /* absent is an answer */ }
+      return { product: name, runId: meta.runId ?? null, template: meta.template ?? null };
+    });
+}
+
+/**
+ * Is this a commit that mixes generated evidence with hand-written source?
+ * Returns the offending paths, or an empty array. PURE given the file list.
+ */
+export function mixedPaths(files) {
+  const demo = files.filter((f) => f.startsWith("demo/"));
+  if (!demo.length) return [];                       // touches no evidence — nothing to say
+  return files.filter((f) => !f.startsWith("demo/"));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const apply = process.argv.includes("--apply");
+
+  if (apply) {
+    writeFileSync(MANIFEST, `${JSON.stringify({
+      note: "What produced the evidence under demo/. Re-recorded by scripts/demo-evidence.mjs --apply in the same commit that regenerates it.",
+      generator: GENERATOR,
+      recordedFromTree: git("rev-parse", "HEAD"),
+      products: products(),
+    }, null, 2)}\n`);
+    console.log(`recorded ${products().length} demo product(s) against ${git("rev-parse", "--short", "HEAD")}`);
+    process.exit(0);
+  }
+
+  // --check: every commit in the range keeps its evidence to itself.
+  const base = process.argv[process.argv.indexOf("--base") + 1] || "origin/main";
+
+  // ── A BASE THIS CHECKOUT CANNOT RESOLVE IS A FAILURE TO LOOK, AND IT SAYS SO ────────────────────
+  //
+  // A shallow clone fetches one branch, so `origin/main` is not a ref in it and `rev-list base..HEAD`
+  // dies on an ambiguous argument — a stack trace naming a line of this file, which reads as a broken
+  // script rather than as a checkout that cannot answer the question. It is neither a clean range nor
+  // a mixed one: nothing was compared. Falling back to another base would be worse, because a range
+  // measured against something the caller did not ask for reports a clean result for a population it
+  // never examined.
+  try { git("rev-parse", "--verify", "--quiet", `${base}^{commit}`); }
+  catch {
+    console.error(`demo-evidence: this checkout has no "${base}", so no commit was compared.`);
+    console.error("");
+    console.error("Nothing is known about the range either way — this is not a clean result. A shallow");
+    console.error("checkout carries only the branch it fetched; fetch the base ref, or name one this");
+    console.error("clone holds with --base.");
+    process.exit(2);
+  }
+
+  const shas = git("rev-list", `${base}..HEAD`).split("\n").filter(Boolean);
+  const bad = [];
+  for (const sha of shas) {
+    const files = git("show", "--name-only", "--pretty=format:", sha).split("\n").filter(Boolean);
+    const mixed = mixedPaths(files);
+    if (mixed.length) bad.push({ sha, mixed });
+  }
+
+  if (!bad.length) {
+    console.log(`demo-evidence: ${shas.length} commit(s) against ${base}; none mixes generated evidence with source.`);
+    process.exit(0);
+  }
+
+  console.error("demo-evidence: generated evidence is mixed with hand-written source.\n");
+  console.error("A reviewer cannot find the source diff inside a regeneration, so in practice nobody reads it.\n");
+  for (const { sha, mixed } of bad) {
+    console.error(`  ${sha.slice(0, 9)} also touches ${mixed.length} non-demo path(s):`);
+    for (const f of mixed.slice(0, 5)) console.error(`      ${f}`);
+    if (mixed.length > 5) console.error(`      …and ${mixed.length - 5} more`);
+  }
+  console.error("\nSplit the regeneration into its own commit:");
+  console.error("  git reset HEAD~ && git add demo && git commit && git add -A && git commit");
+  process.exit(1);
+}

package/scripts/engine-probe.mjs

@@ -10,9 +10,9 @@
 // ── WHY THIS EXISTS ─────────────────────────────────────────────────────────────────────────────────
 //
 // `probeEngineTurn` is the smallest thing that genuinely exercises an engine: one Haiku-tier turn at low
-// effort on a six-word prompt, through the adapter's own spawn path, with no MCP config, no tools, no
-// skills dir and no run dir. It answers the one question an operator asks before spending anything —
-// CAN this box run a turn, and under the billing mode it thinks it is using.
+// effort, through the adapter's own spawn path, asked to call the one tool on the probe's own server, with
+// no skills dir and no run dir. It answers the one question an operator asks before spending anything —
+// CAN this box run a turn that uses a tool, and under the billing mode it thinks it is using.
 //
 // It had no way to be asked. Its only callers were `bin/onboard.mjs` (the setup wizard, which asks it
 // once, inside a flow) and `preflightEngineTurn` in `pipeline.mjs` (which asks it at the start of a run,
@@ -28,8 +28,9 @@
 // ── WHAT A GREEN PROBE DOES NOT PROVE, from the module's own header ─────────────────────────────────
 //
 // The cheap tier only. Both tiers ride one credential, so AUTH is proven for all of them — a per-tier
-// model entitlement or per-tier quota is not. And it sets up no tools, no gather MCP, no skills and no
-// run dir, so none of that path is touched. A probe that says `ok` says the door opens.
+// model entitlement or per-tier quota is not. It calls one tool on its own server, so the tool path is
+// proven and no stage's tool server is; it sets up no skills and no run dir. A probe that says `ok` says
+// the door opens.
 
 // FIRST IMPORT, AND IT HAS TO BE. This entry statically reaches driver.config.mjs, which captures
 // env at module top — and every static import evaluates before this file's own body runs, so applying the

package/scripts/env-audit.mjs

@@ -557,7 +557,7 @@ export function auditEnv(root = ROOT) {
 //                         4  read RIGHT NOW through an idiom no `env`-prefixed regex can reach —
 //                            envValue("CLEAROTRON_MAX_RETRIES") and
 //                            envValue("CLEAROTRON_RATE_LIMIT_DEFAULT_BACKOFF_MS") (driver.config.mjs:486,
-//                            :494), envOn("CLEAROTRON_DUMP_JSON") (gateway.mjs:1423), and
+//                            :494), envOn("CLEAROTRON_DUMP_JSON") (runStageLadder() in gateway.mjs), and
 //                            `export const API_KEY_ENV = "USPTO_API_KEY"` (providers/uspto-local/src/sync.js:77).
 //                            The name is a STRING LITERAL in every one; it just never sits beside an
 //                            `env` token. USPTO_API_KEY is a credential.

package/scripts/freeze-example-run.mjs

@@ -69,8 +69,8 @@ const FROZEN_FILES = [
   { 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:901 scopeBasis" },
-  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:902 searchedJurisdictions, the fallback for register-plan" },
+  { path: "_driver/register-plan.json", why: "publish/index.mjs:910 scopeBasis" },
+  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:911 searchedJurisdictions, the fallback for register-plan" },
   { path: "_driver/enforcer-signals.json", why: "`esPath` declared in index.mjs" },
   { path: "_driver/predelivery-lint.json", why: "publish/index.mjs:172 lintSink" },
   { path: "_driver/escalation-state.json", why: "publish/index.mjs:173 escSink" },
@@ -118,7 +118,7 @@ const KNOCKOUT_FILES = [
   // 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:902 searchedJurisdictions, the fallback for register-plan" },
+  { path: "_driver/instructed-scope.json", why: "publish/index.mjs:911 searchedJurisdictions, the fallback for register-plan" },
 ];
 
 /** The allowlist for a template. One place, so a new template cannot half-exist. */

package/scripts/live-surface-check.mjs

@@ -500,8 +500,8 @@ if (!snapshot) {
     catch { return null; }
   })();
   const { groups: managerGroups, why } = readUserManagerGroups(uid);
-  const { state, message } = managerGroupsVerdict({ idGroups, managerGroups, user, uid, why });
-  ({ pass, fail, skip })[state]("user manager groups are current", message);
+  const v = managerGroupsVerdict({ idGroups, managerGroups, user, uid, why });
+  record("user manager groups are current", v.state, v.message, v.blocked === true);
 }
 
 // 1b. — HOW THIS BOX DIFFERS FROM PRODUCTION on the flags that change output without saying so.
@@ -582,9 +582,9 @@ try {
   try { caller = (await import("../driver/portal-service.mjs")).opsTokenPosture(OPS_TOKEN); }
   catch { /* stays unreadable — the verdict reports what it could not compare */ }
   if (bundledDemos) {
-    const { state, message } = rosterVerdict({ keys, onDisk, bundledDemos, caller,
+    const v = rosterVerdict({ keys, onDisk, bundledDemos, caller,
       expectDemos: process.env.CLEAROTRON_E2E_EXPECT_DEMO_ROSTER === "1" });
-    ({ pass, fail, skip })[state]("roster resolves", message);
+    record("roster resolves", v.state, v.message, v.blocked === true);
   }
   // A COMPANY IN THE STORE THAT THIS KEY CANNOT START is its own finding, not a roster disagreement. A
   // warning, not a failure: the portal re-takes its credential at the start of every call, so a Start for
@@ -639,7 +639,7 @@ try {
       effectiveMode: (process.env.TRADEMARK_MCP_AUTH_MODE || "").trim().toLowerCase() === "token" ? "token" : "cf-access",
       allowedHosts: (process.env.TRADEMARK_MCP_ALLOWED_HOSTS || "").split(",").map((h) => h.trim()).filter(Boolean),
     });
-    record("the ops door's auth mode was chosen for it", posture.state, posture.message);
+    record("the ops door's auth mode was chosen for it", posture.state, posture.message, posture.blocked === true);
   }
 } catch (e) {
   if (e?.message === "__door_unset__") skip("ops-MCP reachable", "this instance does not say where its ops-MCP is — NOT PROBED");
@@ -827,11 +827,12 @@ else {
 // process that is in no unit, so this arm derives from the PROCESS TABLE and from a stamp the drainer
 // writes about itself.
 //
-// IT FAILS ON COULD-NOT-LOOK, and that is deliberate. This script exits non-zero on `fail` only —
-// `skip` does not move the exit code — so recording an absent stamp as a skip would let the deploy
-// report a build live having never established what the executing process holds, which is the exact
-// state the incident's drainer was in. The fourth criterion of that issue is that the deploy does not
-// report a build live until this arm has looked; a skip here would be that criterion silently unmet.
+// A COULD-NOT-LOOK HERE MOVES THE EXIT CODE, and that is deliberate. An ordinary skip does not, so
+// recording an absent stamp as one would let the deploy report a build live having never established
+// what the executing process holds, which is the exact state the incident's drainer was in. It is
+// recorded through `blocked`, which exits 3 rather than the 1 a drift gives: the deploy still does not
+// report a build live until this arm has looked, and the reader is told it could not look rather than
+// that something drifted.
 {
   let workspaceRoot = null, resolveError = null;
   try { workspaceRoot = config.workspaceRoot; }
@@ -937,7 +938,7 @@ else {
       // which tree this deploy is. Reading it twice is how they would come to.
       deployClone,
     });
-    record("the updater that deploys this box is the current one", v.state, v.message);
+    record("the updater that deploys this box is the current one", v.state, v.message, v.blocked === true);
   }
   }
 }
@@ -947,10 +948,10 @@ else {
 // inline string equality over a two-word vocabulary, which is why a `Type=oneshot` doing its job read as
 // a fault on the deploy's final gate. The decision now lives in driver/unit-state-verdict.mjs, where a
 // test can reach it — same move made for the roster arm, for the same reason.
-// `record`, not the ({pass, fail, skip})[state] shorthand used above: `warn` is a real outcome here.
+// `record`, not a ({pass, fail, skip})[state] shorthand: `warn` is a real outcome here.
 {
   const v = unitsActiveVerdict({ units: clones, probe: unitProbe });
-  record("units active", v.state, v.message);
+  record("units active", v.state, v.message, v.blocked === true);
 }
 
 // 10. — THE UNIT A BOX RUNS versus the unit the deployed commit SHIPS. The deploy syncs code, not
@@ -1013,7 +1014,7 @@ else {
     return { unit: fragName ?? c.unit, live, tracked, dropIns };
   });
   const v = unitFileDriftVerdict({ units: rows, probe: unitProbe });
-  record("units match the deployed commit", v.state, v.message);
+  record("units match the deployed commit", v.state, v.message, v.blocked === true);
 }
 
 // 10a. — IS EVERY UNIT THIS BOX RUNS ACCOUNTED FOR AT ALL?
@@ -1082,7 +1083,7 @@ else {
   const box = deploymentBox();   // — the shared rule, so /portal/health cannot disagree with this
   const v = unitInventoryVerdict({ live: liveUnits, files: walk.files, collisions: walk.collisions,
     filesError: walk.error, box, probe, boxNames: DEPLOYMENT_BOXES });
-  record("every live unit is declared", v.state, v.message);
+  record("every live unit is declared", v.state, v.message, v.blocked === true);
 
   // — AND WHETHER ANYTHING STILL STARTS THE TIMER-DRIVEN ONES. Reported separately from the line above
   // because it answers a different question: that one says a declared unit exists and is not adrift,
@@ -1090,7 +1091,7 @@ else {
   // fails the second, and reads `inactive` for both — which is why one line could not carry both.
   const t = declaredTimers();
   const tv = timerVerdict(t.rows, { probeFailed: t.probeFailed });
-  record("every declared timer is still armed", tv.state, tv.message);
+  record("every declared timer is still armed", tv.state, tv.message, tv.blocked === true);
 }
 
 // ── — EVERY QUEUE THIS DEPLOYMENT WOULD DRAIN IS WATCHED BY SOMETHING ──────────────────────────
@@ -1116,7 +1117,7 @@ else {
   // job's life, and two readers of one unit file is how the deploy tick and a door come to different
   // conclusions about the same box. The unit path now has one home.
   const v = probeQueueWatch({ queueDirs, resolveError });
-  record("every queue this deployment would drain is watched", v.state, v.message);
+  record("every queue this deployment would drain is watched", v.state, v.message, v.blocked === true);
 }
 
 // ── report ───────────────────────────────────────────────────────────────────────────────────────────
@@ -1129,8 +1130,14 @@ const couldNotLook = results.filter((r) => r.blocked);
 // — extracted for the reason roster-verdict and unit-state-verdict were: this file is a program, and a
 // decision that can only be reached by running it is a decision nobody can drive.
 
+// ONE DECISION, READ BY BOTH SURFACES. `--json` used to print `ok: failed.length === 0`, so a run that
+// could not look at a surface and found nothing else wrong told a machine reader `ok: true` while the
+// terminal said COULD NOT LOOK and the process exited 3. The human surface was fixed and the one a script
+// believes silently was not. `ok` is now the exit code's own answer, and `exit` carries which of the three.
+const code = exitFor({ failed: failed.length, couldNotLook: couldNotLook.length });
+
 if (asJson) {
-  console.log(JSON.stringify({ ok: failed.length === 0, poolRoot: POOL_ROOT, register: wiredRegister, results }, null, 2));
+  console.log(JSON.stringify({ ok: code === 0, exit: code, poolRoot: POOL_ROOT, register: wiredRegister, results }, null, 2));
 } else {
   const mark = { pass: "  ok  ", fail: " FAIL ", warn: " warn ", skip: " skip " };
   console.log(`\n== live surface check — ${POOL_ROOT} ==\n`);
@@ -1148,4 +1155,4 @@ if (asJson) {
   }
 }
 
-process.exit(exitFor({ failed: failed.length, couldNotLook: couldNotLook.length }));
+process.exit(code);

package/scripts/mint-suite-census.mjs

@@ -148,6 +148,60 @@ export function laidPathVerdict({ laid = 0, laidPaths = [], cutRecordPresent = f
  * A tree with no HEAD cannot say what it published. That is a failure to look, and it exits rather
  * than reading as "nothing is laid here", which is the permissive answer and the one that passes.
  */
+/**
+ * — A HALF-FINISHED MERGE CANNOT SAY WHAT ITS SUITE IS, and it does not know that it cannot.
+ *
+ * The refusal above catches one of the two ways a mid-merge tree lies to this script: a path arriving
+ * from the other parent is in the index and not in HEAD, so it is laid, named and refused. It cannot
+ * catch the other. A file both parents changed IS in HEAD, so nothing about it is laid — it is counted,
+ * and what is counted is a working copy holding `<<<<<<<`, `=======` and `>>>>>>>` as though they were
+ * source. Measured 2026-09-21 on a tree conflicted in one test file: the mint read all 980 driver
+ * files, counted the conflicted one, printed "unchanged — no file added, removed, grown, shrunk or
+ * newly skipped", and exited 0. The operator's confirmation and the defect are the same sentence.
+ *
+ * THE STATE IS THE TEST, NOT THE MARKERS. Scanning files for marker lines would find this instance and
+ * would also refuse a test that legitimately contains one in a string, while missing a conflict
+ * resolved into plausible nonsense. Git already publishes the fact: an operation is half-finished, so
+ * no tree it produced is a population anyone should stamp. That covers both mechanisms at once, and
+ * covers a rebase and a cherry-pick, where the same two lies are available for the same reason.
+ *
+ * REFUSES RATHER THAN REPAIRS. Reading the index instead of HEAD would fix the counting and would still
+ * mint over markers, so it is the weaker of the two. There is a correct tree a few seconds away —
+ * finish the operation and mint on the result — and the census is a deliberate act whose whole value is
+ * that somebody looked at the diff.
+ *
+ * Pure, and takes the list rather than reading it, so both branches can be driven without a test
+ * having to conflict a real tree.
+ */
+export const MID_OPERATION_STATES = Object.freeze([
+  ["MERGE_HEAD", "merge"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase"],
+]);
+
+export function midOperationVerdict({ inProgress = [] } = {}) {
+  if (!inProgress.length) return { refuse: false, message: null };
+  const what = [...new Set(inProgress.map(([, label]) => label))].join(" and a ");
+  return { refuse: true,
+    message: `mint-suite-census: this tree is in the middle of a ${what}, so the files in it are not a\n`
+      + "  population anybody published. A path from the other parent is missing from HEAD and would be\n"
+      + "  dropped from the count; a file both sides changed is in HEAD and would be counted WITH its\n"
+      + "  conflict markers. Either way this would print \"unchanged\" for a population it had just\n"
+      + `  misread. Finish the ${what} and mint on the tree that comes out.` };
+}
+
+/** Which half-finished operations this worktree's own git directory is carrying. */
+export function operationsInProgress(root, exists = existsSync) {
+  let gitDir;
+  try {
+    gitDir = execFileSync("git", ["-C", root, "rev-parse", "--absolute-git-dir"], { encoding: "utf8" }).trim();
+  } catch { return []; }
+  if (!gitDir) return [];
+  return MID_OPERATION_STATES.filter(([name]) => exists(join(gitDir, name)));
+}
+
 /**
  * The paths the private overlay says it laid over this clone, or null where it laid nothing.
  *
@@ -219,6 +273,18 @@ export function buildCensus(root = ROOT) {
 const readManifest = (rel) => { try { return JSON.parse(readFileSync(join(ROOT, rel), "utf8")); } catch { return null; } };
 
 function main() {
+  // ── BEFORE EVEN THAT — IS THIS TREE A POPULATION AT ALL? ────────────────────────────────────
+  //
+  // First, because every check below reads files from this working tree, and mid-merge those files are
+  // not what either parent published. A census that is internally consistent about a tree nobody
+  // committed passes every other refusal in this file, `--check` included.
+  const mid = midOperationVerdict({ inProgress: operationsInProgress(ROOT) });
+  if (mid.refuse) {
+    console.error(`\nREFUSING — ${mid.message}`);
+    process.exitCode = 2;
+    return;
+  }
+
   // ── ITEM 1 — BEFORE ANY COUNTING, DOES THIS CENSUS DESCRIBE WHAT THE RUNNER RUNS? ───────────
   //
   // FIRST, and it refuses rather than warns. Everything below counts files inside a corpus this list