clearotron 0.4.1-beta.3 → 0.4.1-beta.4

package/README.md

@@ -8,6 +8,7 @@
 <p align="center">
   <a href="LICENSE"><img src="https://img.shields.io/badge/licence-AGPL--3.0--only-860F09?style=flat-square" alt="Licence: AGPL-3.0-only"></a>
   <a href=".nvmrc"><img src="https://img.shields.io/badge/node-%E2%89%A5%2022.13-250902?style=flat-square" alt="Node 22.13+"></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/CordilleraSarl/clearotron"><img src="https://img.shields.io/ossf-scorecard/github.com/CordilleraSarl/clearotron?label=openssf%20scorecard&style=flat-square" alt="OpenSSF Scorecard"></a>
 </p>
 
 Before your company commits to a name, find out what stands in its way. Give Clearotron the name, the

package/build-info.json

@@ -1,4 +1,4 @@
 {
-  "commit": "38d43f7a215c87092fd2cc233812b3aff17e1e82",
-  "version": "0.4.1-beta.3"
+  "commit": "103da45d8abcbbe5af51cacd213954a3cc59c841",
+  "version": "0.4.1-beta.4"
 }

package/driver/CHANGELOG.md

@@ -1,5 +1,11 @@
 # clearotron-driver
 
+## 0.4.1-beta.4
+
+### Patch Changes
+
+- Fixed: Every clearance uses the same web search whichever engine runs it; the engines' own web search is switched off.
+
 ## 0.4.1-beta.3
 
 ### Patch Changes

package/driver/config-inventory.mjs

@@ -499,30 +499,22 @@ export function caseLawInventory(env = process.env) {
     remedy: null,
   });
 
-  // ── THE TWO THE REPORT NAMED AND THIS BUILD DOES NOT SHIP ────────────────────────────────────────
+  // ── THE ONE THE REPORT NAMED AND THIS BUILD DOES NOT SHIP ────────────────────────────────────────
   //
-  // "no EUIPO Boards-of-Appeal source" and "WebSearch unavailable this session" were the other two gaps
-  // in the same report, and the issue asks for the same treatment. They get it, and the treatment is to
-  // say what is TRUE of each rather than to invent a switch:
+  // "no EUIPO Boards-of-Appeal source" was another gap in the same report, and the treatment is to say
+  // what is TRUE of it rather than to invent a switch: the Boards of Appeal have no adapter in this build.
+  // That is a release fact, not a setting, and an operator can do nothing about it — which is precisely
+  // what they need to be told before they spend two hours discovering it from a report.
   //
-  //   · the Boards of Appeal have no adapter in this build. That is a release fact, not a setting, and
-  //     an operator can do nothing about it — which is precisely what they need to be told before they
-  //     spend two hours discovering it from a report.
-  //   · WebSearch is the engine's own tool. Whether it answers is decided per session by the engine, so
-  //     no deployment check can promise it. Recorded as a capability with a stated limit rather than as
-  //     a green tick this file cannot honestly give.
+  // The engine's own web search had a row here too. It is off on both engines now (OWN_SEARCH_TOOLS in
+  // engine/anthropic-agent.mjs, `web_search` in engine/mcp/codex-config.mjs), so it has none: the open-web
+  // row a run actually uses is the research provider's, above.
   rows.push({
     key: "caselaw", label: "Case law and oppositions", provider: "euipo-boards-of-appeal",
     providerLabel: "EUIPO Boards of Appeal", known: false, enrolment: "absent", configured: false, missing: [],
     remedy: "Not part of this build. There is no adapter for it, so no setting turns it on and a report "
       + "covering the EU discloses it as a gap. Nothing to fix on this box.",
   });
-  rows.push({
-    key: "web", label: "Open-web search", provider: "engine-websearch",
-    providerLabel: "The engine's own web search", known: true, enrolment: "built-in", configured: true, missing: [],
-    remedy: "Provided by the engine, not by this deployment, and it can be unavailable for a single "
-      + "session. A run that loses it discloses the gap rather than reporting a clean sweep.",
-  });
   return rows;
 }
 

package/driver/contract-vocabulary.mjs

@@ -16,8 +16,8 @@
 // extractor never sees:
 //
 //   D1 verify.mjs connotationDispositionFail   fail(`connotation_${reason}:…`)   — reason is a member of CALL_REASON_SET
-//   D2 verify.mjs   fail(String(e.message))              — parseFindingsJson throws token-first
-//   D3 verify.mjs:1237   checkJson: fail(String(e.message))   — FIVE parsers reach this one site
+//   D2 verify.mjs checkFindingsSibling  fail(String(e.message)…)  — parseFindingsJson throws token-first
+//   D3 verify.mjs:1240   checkJson: fail(String(e.message)…)   — FIVE parsers reach this one site
 //   D4 verify.mjs  parseCoverageLedgerJson, same shape
 //   D5 verify.mjs validators.registerFindings  fail(`${unaccounted[0].token}:…`)  — token minted in a DATA ROW
 //   D6 verify.mjs validators.registerFindings  fail(`${violations[0].token}…`)  — findUnexecutedCleanClaims() in register-plan.mjs

package/driver/engine/anthropic-agent.mjs

@@ -370,6 +370,14 @@ export function runDirGrant({ runDir, dispatch, seatWrites = null } = {}) {
  * shell the program offered them anyway.
  */
 export const COMMAND_TOOLS = Object.freeze(["Bash", "PowerShell", "Monitor"]);
+/**
+ * The program's own web search, removed from every stage by the same name-removal. The engine's web search
+ * is its own: the common-law sweep, which keeps a record of every result. The program's was never granted,
+ * and every attempt a stage made at it was refused, a turn spent for nothing (observed in testing,
+ * 2026-10-02 and 2026-10-03: 48 attempts in five runs, all refused). Removed, the model is never offered it.
+ * The codex engine turns its own off the same way (`web_search`, codex-config.mjs).
+ */
+export const OWN_SEARCH_TOOLS = Object.freeze(["WebSearch"]);
 /** The program's tools that write a file. A result that comes back an error is a write that failed. */
 const FILE_WRITE_TOOLS = Object.freeze(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
 
@@ -399,7 +407,7 @@ export function buildClaudeArgs({ message, model, thinking, resumeRef, mcpConfig
   // through Bash on a login with no rule allowing it. A bare name here "removes the matching tools from
   // Claude's context" (the vendor's CLI reference, `--disallowedTools`), on every call, the resumed one
   // included, so the model is never offered them. See COMMAND_TOOLS for the three names.
-  args.push("--disallowedTools", COMMAND_TOOLS.join(" "));
+  args.push("--disallowedTools", [...COMMAND_TOOLS, ...OWN_SEARCH_TOOLS].join(" "));
   const cap = maxBudgetUsd ?? (process.env.CLEAROTRON_MAX_BUDGET_USD ? Number(process.env.CLEAROTRON_MAX_BUDGET_USD) : null);
   if (cap != null && Number.isFinite(cap)) args.push("--max-budget-usd", String(cap));
   // FILE ACCESS: claude's Read/Write/Edit tools are confined to cwd + --add-dir roots even under
@@ -593,6 +601,8 @@ export const anthropicAgentEngine = {
       let lastMove = Date.now();
       let lastProgress = Date.now();            // honest-progress clock: token movement / agent-loop steps / artifact writes ONLY
       let firstOutputAt = null;                 // #1692/#1813 — first byte of the PROTOCOL (stdout only); until then every clock below is timing STARTUP
+      let atKill = null;                        // what the watchdog had seen when it decided to kill — recording only, see killDecision
+      let silentIdleMs = null;                  // the no-progress clock at the watchdog's last look before the child spoke — recording only
       const GRACE = spawnGraceMs();             // one source of the grace: common.mjs, where #1703 set it
       let sawAnyEvent = false;                  // ANY parseable stream event (incl. system:init) — false on close = the CLI died before streaming (startup-class failure)
       let rateLimitEvent = null;   // a 429 session-cap rejection rides a `rate_limit_event` (status:"rejected" + resetsAt)
@@ -957,6 +967,7 @@ export const anthropicAgentEngine = {
         ? (sig) => { const n = killWindowsTreeNow({ pid: child.pid, since: spawnedAt, until: exitedAt }); if (!n && sig === "SIGTERM") process.stderr.write(`[engine] the Windows stop found nothing of this turn left to end (program ${child.pid})\n`); }
         : (sig) => { try { process.kill(-child.pid, sig); } catch { try { child.kill(sig); } catch { /* already gone */ } } };
       const killTree = () => {
+        atKill ??= { ms: Date.now() - t0, spoken: firstOutputAt !== null, toolCalls };
         if (escalation) return;   // the watchdog polls — arm the escalation exactly once
         groupKill("SIGTERM");
         escalation = setTimeout(() => groupKill("SIGKILL"), killEscalateMs());
@@ -1009,6 +1020,7 @@ export const anthropicAgentEngine = {
         // was recorded as a no-progress stall against a turn that had not yet been given a chance to
         // progress. A child that never speaks AT ALL is still bounded: the byte-stall fires at max(STALL, GRACE).
         const started = firstOutputAt !== null;
+        if (!started) silentIdleMs = progIdle;
         if (idle >= (started ? STALL : Math.max(STALL, GRACE))) { stallKill = true; killed = true; killTree(); }
         // No observable progress (tokens/agent-loop/artifact) for NOPROG while bytes kept the pipe warm:
         // kill it NOW, well below the wall, and record it as a STALL — never let the ceiling raise turn
@@ -1220,6 +1232,16 @@ export const anthropicAgentEngine = {
           // ONLY: nothing branches on it. A recording field is protected by a test or by nothing, so
           // engine.anthropic.test.mjs pins it — deleting it must red something.
           firstByteMs: firstOutputAt === null ? null : Math.round(firstOutputAt - t0),
+          // WHICH SIDE OF THE KILL a byte or a tool ask fell on. RECORDING ONLY, like firstByteMs. The
+          // totals above keep counting after the decision, because what a dying child already wrote is
+          // still read (streamed usage depends on it). On Windows the kill blocks this process while it
+          // lists and ends the tree, measured at one to three seconds on the hosted runner, which is long
+          // enough for a booting child to speak and open a tool ask that is read only afterwards.
+          // `killDecision` is what the watchdog had seen when it decided: ms from spawn, whether the child
+          // had spoken, and the tool asks read by then; null when nothing was killed. `silentIdleMs` is how
+          // long the no-progress clock had run at the watchdog's last look before the child spoke; null
+          // when it never looked at a silent child.
+          killDecision: atKill, silentIdleMs,
           // WHICH CLOCK RAN OUT, and WHAT the wait was made of.
           //
           // The hard wall measures ELAPSED, and elapsed includes time the model spent waiting on tools

package/driver/engine/mcp/codex-config.mjs

@@ -153,6 +153,14 @@ export function renderCodexConfigToml({ mcpConfig, allowedTools, developerInstru
   if (developerInstructions) lines.push(`developer_instructions = ${tomlString(developerInstructions)}`, "");
   // Top-level, so above the first table: TOML reads a bare key after a table header as that table's.
   if (fence) lines.push(`default_permissions = ${tomlString(FENCE_PROFILE)}`, "");
+  // CODEX'S OWN WEB SEARCH IS OFF, ON EVERY STAGE AND IN EVERY SAFETY SETTING. The engine's web search is its
+  // own: the common-law sweep, which keeps a record of every result. Codex brings a search of its own that
+  // is on unless the configuration says otherwise, "cached" by default and "live" once the sandbox is
+  // bypassed, and `"disabled"` removes the tool (the vendor's configuration reference, `web_search`). Left
+  // on, it fired in some runs and not others and brought web addresses into the placement notes that no
+  // recorded search returned (observed in testing, 2026-10). The Claude engine removes its own the same way
+  // (OWN_SEARCH_TOOLS, anthropic-agent.mjs). The case-law step's page fetcher is a tool server, not this.
+  lines.push(`web_search = "disabled"`, "");
   lines.push(...commandEnvToml(withheldFromCommands));
 
   const emitServer = (name, s, { forwardCreds } = {}) => {

package/driver/package.json

@@ -2,7 +2,7 @@
   "name": "clearotron-driver",
   "private": true,
   "type": "module",
-  "version": "0.4.1-beta.3",
+  "version": "0.4.1-beta.4",
   "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/suite-census.json

@@ -981,6 +981,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-pin-change-asks-for-a-bench-replay.test.mjs": {
+          "tests": 16,
+          "asserts": 37,
+          "skips": 0,
+          "todos": 0
+        },
         "a-placement-pass-that-lost-its-answers-does-not-succeed.test.mjs": {
           "tests": 7,
           "asserts": 17,
@@ -3101,8 +3107,8 @@
         },
         "engine.anthropic.test.mjs": {
           "tests": 70,
-          "asserts": 260,
-          "skips": 1,
+          "asserts": 262,
+          "skips": 2,
           "todos": 0
         },
         "engine.codex-config.test.mjs": {
@@ -3867,6 +3873,12 @@
           "skips": 0,
           "todos": 0
         },
+        "no-stage-is-offered-the-engines-own-web-search.test.mjs": {
+          "tests": 4,
+          "asserts": 10,
+          "skips": 0,
+          "todos": 0
+        },
         "no-test-account-reaches-the-package.test.mjs": {
           "tests": 17,
           "asserts": 31,
@@ -5817,6 +5829,12 @@
           "skips": 0,
           "todos": 0
         },
+        "the-engine-pins-come-from-the-tree.test.mjs": {
+          "tests": 6,
+          "asserts": 24,
+          "skips": 0,
+          "todos": 0
+        },
         "the-engine-sets-no-sampling-and-forces-no-tool.test.mjs": {
           "tests": 6,
           "asserts": 9,

package/mcp-server/CHANGELOG.md

@@ -1,5 +1,9 @@
 # trademark-artifacts-mcp
 
+## 0.4.1-beta.4
+
+No changes in this release.
+
 ## 0.4.1-beta.3
 
 No changes in this release.

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-artifacts-mcp",
-  "version": "0.4.1-beta.3",
+  "version": "0.4.1-beta.4",
   "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

@@ -2,7 +2,7 @@
   "name": "clearotron",
   "mcpName": "io.github.CordilleraSarl/clearotron",
   "type": "module",
-  "version": "0.4.1-beta.3",
+  "version": "0.4.1-beta.4",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

package/portal-ui/dist/assets/{index-BPAUjcI0.js → index-DcLbvFmQ.js}

@@ -25046,8 +25046,7 @@ function engineCapabilityRows(providers) {
 		ok: p.configured,
 		name: splitSourceLabel(p.providerLabel ?? p.provider ?? "").name.replace(/'/g, "’"),
 		mono: "provided by the engine",
-		state: p.configured ? "Available" : "Not available",
-		note: "The model searches the web itself during a run."
+		state: p.configured ? "Available" : "Not available"
 	}));
 }
 function providerRow(p) {

package/portal-ui/dist/index.html

@@ -36,7 +36,7 @@
       chosen anywhere in the product holds everywhere in it.
     -->
     <script>(function(){try{var t=localStorage.getItem('cordillera-theme');if(t==='dark'||t==='light')document.documentElement.setAttribute('data-theme',t);}catch(e){}})();</script>
-    <script type="module" crossorigin src="/portal/assets/index-BPAUjcI0.js"></script>
+    <script type="module" crossorigin src="/portal/assets/index-DcLbvFmQ.js"></script>
     <link rel="stylesheet" crossorigin href="/portal/assets/index-D2wrw9cH.css">
   </head>
   <body>

package/portal-ui/package.json

@@ -2,7 +2,7 @@
   "name": "portal-ui",
   "private": true,
   "type": "module",
-  "version": "0.4.1-beta.3",
+  "version": "0.4.1-beta.4",
   "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": {
@@ -24,6 +24,6 @@
     "@types/react-dom": "^19.3.0",
     "@vitejs/plugin-react": "^6.1.2",
     "typescript": "^7.0.2",
-    "vite": "^8.3.3"
+    "vite": "^8.3.4"
   }
 }

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

@@ -1,5 +1,9 @@
 # trademark-oauth-mcp-bridge
 
+## 0.4.1-beta.4
+
+No changes in this release.
+
 ## 0.4.1-beta.3
 
 No changes in this release.

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

@@ -1,6 +1,6 @@
 {
   "name": "trademark-oauth-mcp-bridge",
-  "version": "0.4.1-beta.3",
+  "version": "0.4.1-beta.4",
   "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/bench-replay-request.mjs

@@ -0,0 +1,111 @@
+// 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
+//
+// bench-replay-request.mjs — ask for a replay of saved cases when a push moved the engine pins.
+//
+//   node scripts/bench-replay-request.mjs     # in the push workflow; reads SHA, BEFORE, REPO, GH_TOKEN
+//
+// A change to a model or an engine program's floor changes what a clearance reads and writes while every
+// test around it stays green, so it is replayed on saved cases before the beta that carries it is cut.
+// This is the request: a `bench replay` status on the pushed commit, `pending` with the description
+// `waiting`. The machine that holds the saved cases picks it up, replays, and sets pass or flag. Nothing
+// waits for it here and nothing is blocked; the cut reads it (release-bench-replay-check.mjs).
+//
+// WHAT IS COMPARED. The pushed commit against the branch's previous tip (BEFORE), both judged by THIS
+// commit's rule (engine-pins.mjs), so a tree from before that script existed still gets a real answer.
+// A new branch has no previous tip and is compared with where it leaves main. Equal pins post nothing.
+// A parent this rule cannot read posts `waiting` too: "could not tell" is never "unchanged".
+//
+// A SQUASH ON MAIN ASKS ONCE. When the pushed commit is the squash of a pull request whose head already
+// carries a final answer for the same pins, that answer is copied rather than asked for again.
+//
+// The status carries the context and one word, never a link, a count or a case: it sits on a public commit.
+//
+// Exit 0: done (posted, copied, or nothing to ask). Exit 2: could not look.
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { pinState } from "./engine-pins.mjs";
+import { isEntrypoint } from "../shared/is-entrypoint.mjs";
+
+export const CONTEXT = "bench replay";
+export const PIN_FILES = ["driver/engine/openai-agent.mjs", "driver/driver.config.mjs"];
+const NO_COMMIT = /^0+$/;
+
+const git = (args, cwd) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+
+/** The pins of `commit`, judged by the rule in this checkout: its two pin files, laid into a scratch tree. */
+export function pinsAt(commit, { cwd = process.cwd() } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), "engine-pins-"));
+  try {
+    for (const rel of PIN_FILES) {
+      let text;
+      try { text = execFileSync("git", ["show", `${commit}:${rel}`], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 64 * 1024 * 1024 }); }
+      catch { continue; }   // absent at that commit: the rule below says could-not-look, by name
+      mkdirSync(dirname(join(dir, rel)), { recursive: true });
+      writeFileSync(join(dir, rel), text);
+    }
+    return pinState(dir);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+/** The latest `bench replay` state on `sha`, or null. `api(path)` answers a GitHub REST GET. */
+export async function latestReplay(api, sha) {
+  const statuses = await api(`commits/${sha}/statuses?per_page=100`);
+  const mine = statuses.filter((s) => s.context === CONTEXT);   // newest first, as the API lists them
+  return mine.length ? { state: mine[0].state, description: mine[0].description ?? "" } : null;
+}
+
+/**
+ * What to post on `sha`, or null for nothing. PURE apart from the injected readers, so each path is tested
+ * without a repository or a network: `pins(commit)` returns a pin state or throws; `squashHead()` names the
+ * merged pull request's head when `sha` is a squash on main, else null; `replay(sha)` is latestReplay.
+ */
+export async function decide({ sha, parent, pins, squashHead, replay }) {
+  const head = pins(sha);
+  let before = null;
+  try { before = pins(parent); } catch { /* could not tell: ask */ }
+  if (before && before.digest === head.digest) return null;
+  const prHead = await squashHead();
+  if (prHead) {
+    let prPins = null;
+    try { prPins = pins(prHead); } catch { /* could not tell: ask */ }
+    const answer = prPins && prPins.digest === head.digest ? await replay(prHead) : null;
+    if (answer && (answer.state === "success" || answer.state === "failure")) return answer;
+  }
+  return { state: "pending", description: "waiting" };
+}
+
+if (isEntrypoint(import.meta.url)) {
+  const { SHA, BEFORE = "", REPO, GH_TOKEN } = process.env;
+  if (!SHA || !REPO || !GH_TOKEN) { process.stderr.write("bench-replay-request: SHA, REPO and GH_TOKEN are required\n"); process.exit(2); }
+  const api = async (path, init = {}) => {
+    const r = await fetch(`https://api.github.com/repos/${REPO}/${path}`, {
+      ...init, headers: { authorization: `Bearer ${GH_TOKEN}`, accept: "application/vnd.github+json", ...(init.headers ?? {}) } });
+    if (!r.ok) throw new Error(`${init.method ?? "GET"} ${path}: ${r.status}`);
+    return r.json();
+  };
+  try {
+    const parent = BEFORE && !NO_COMMIT.test(BEFORE) ? BEFORE : git(["merge-base", "origin/main", SHA]);
+    const decision = await decide({
+      sha: SHA, parent,
+      pins: (c) => pinsAt(c),
+      squashHead: async () => {
+        const pulls = await api(`commits/${SHA}/pulls`);
+        const pr = pulls.find((p) => p.merge_commit_sha === SHA && p.merged_at);
+        if (!pr) return null;
+        git(["fetch", "--quiet", "origin", `refs/pull/${pr.number}/head`]);
+        return pr.head.sha;
+      },
+      replay: (s) => latestReplay(api, s),
+    });
+    if (!decision) { console.log(`bench-replay-request: the engine pins did not move against ${parent.slice(0, 12)}; nothing to ask`); process.exit(0); }
+    await api(`statuses/${SHA}`, { method: "POST", body: JSON.stringify({ state: decision.state, context: CONTEXT, description: decision.description }) });
+    console.log(`bench-replay-request: ${CONTEXT} set to ${decision.state} (${decision.description}) on ${SHA.slice(0, 12)}`);
+  } catch (e) {
+    process.stderr.write(`bench-replay-request: could not look — ${e.message}\n`);
+    process.exit(2);
+  }
+}

package/scripts/engine-pins.mjs

@@ -0,0 +1,117 @@
+// 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
+//
+// engine-pins.mjs — the engine pins a tree carries: the models the Codex engine asks for, and the program
+// each engine runs, with the oldest version it accepts.
+//
+//   node scripts/engine-pins.mjs                # the tree this script sits in
+//   node scripts/engine-pins.mjs --root <dir>   # another tree, judged by this script's rule
+//
+// WHY IT EXISTS. A change to a model or to an engine program's floor changes what a clearance reads and
+// writes, while every test of the code around it stays green. Such a change asks for a replay of saved
+// cases before the beta that carries it is cut. This is the one definition of "such a change": the push
+// workflow compares a commit with its parent by it, the cut compares the last published version with
+// main by it, and the replay reads it to see which engine moved. A second copy of the rule would drift.
+//
+// WHAT COUNTS. The three Codex model defaults in driver/engine/openai-agent.mjs (JUDGMENT, SWEEP and
+// CHEAP), and the `package` and `floor` of both entries in ENGINE_BINARIES in driver/driver.config.mjs.
+// The Claude engine asks for a tier by name and its program resolves it, so for Claude the program's
+// floor IS the model choice. Values are parsed, not lines: an edited comment or a moved line is not a
+// change. Left out on purpose: the tier each stage asks for, and anything a box's settings override.
+//
+// IT NEVER READS THE ENVIRONMENT. Each model default sits behind a setting that overrides it on a box;
+// this reports the source's default, so two machines with different settings print the same pins for one
+// tree. Judging an older tree with --root applies THIS script's rule to it, which is how a tree from
+// before this script existed still gets an answer.
+//
+// OUTPUT: one line of JSON, keys sorted at every level, no spaces:
+//   {"digest":"sha256:<hex>","pins":{"anthropic-agent":{"floor","package"},"openai-agent":{"floor","models":{"cheap","judgment","sweep"},"package"}},"schema":1}
+// `digest` is the sha256 of `pins` alone in that same form, so equal digests are equal pins; `schema`
+// sits outside it, so a change of format never reads as a change of pins.
+//
+// Exit 0: printed. Exit 2: could not look — a file missing, or a value not found exactly once. The reason
+// goes to stderr and nothing to stdout, because a partial answer compared as a whole reads as a change or,
+// worse, as none.
+
+import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isEntrypoint } from "../shared/is-entrypoint.mjs";
+
+export const SCHEMA = 1;
+const MODELS_FILE = "driver/engine/openai-agent.mjs";
+const BINARIES_FILE = "driver/driver.config.mjs";
+const ENGINES = ["anthropic-agent", "openai-agent"];
+const CODEX_MODELS = { judgment: "JUDGMENT", sweep: "SWEEP", cheap: "CHEAP" };
+
+class CouldNotLook extends Error {}
+
+/** Exactly one match of `re` in `text`, or could-not-look naming `what`. */
+function one(text, re, what) {
+  const found = [...text.matchAll(re)];
+  if (found.length !== 1) throw new CouldNotLook(`${what}: found ${found.length} time(s), expected exactly 1`);
+  return found[0];
+}
+
+/** The source with whole-line comments removed, so a commented-out value is not a value. */
+const code = (text) => text.split("\n").filter((l) => !/^\s*\/\//.test(l)).join("\n");
+
+function read(root, rel) {
+  try { return readFileSync(join(root, rel), "utf8"); }
+  catch (e) { throw new CouldNotLook(`${rel}: ${e.code ?? e.message}`); }
+}
+
+/** The pins of the tree at `root`. Throws CouldNotLook when any value cannot be read exactly once. */
+export function readPins(root) {
+  const models = code(read(root, MODELS_FILE));
+  const codex = {};
+  for (const [key, name] of Object.entries(CODEX_MODELS)) {
+    const re = new RegExp(`^const ${name}\\s*=\\s*process\\.env\\.CLEAROTRON_OPENAI_MODEL_${name}\\s*\\|\\|\\s*"([^"]+)"\\s*;`, "gm");
+    codex[key] = one(models, re, `${MODELS_FILE} ${name}`)[1];
+  }
+  const binaries = code(read(root, BINARIES_FILE));
+  const table = one(binaries, /^export const ENGINE_BINARIES = \{\n([\s\S]*?)^\};/gm, `${BINARIES_FILE} ENGINE_BINARIES`)[1];
+  const pins = {};
+  for (const engine of ENGINES) {
+    const start = one(table, new RegExp(`^ {2}"${engine}":\\s*\\{`, "gm"), `${BINARIES_FILE} ${engine}`).index;
+    const rest = table.slice(start + 1);
+    const next = rest.search(/^ {2}"[a-z-]+":\s*\{/m);
+    const entry = next === -1 ? rest : rest.slice(0, next);
+    pins[engine] = {
+      package: one(entry, /\bpackage:\s*"([^"]+)"/g, `${BINARIES_FILE} ${engine} package`)[1],
+      floor: one(entry, /\bfloor:\s*"([^"]+)"/g, `${BINARIES_FILE} ${engine} floor`)[1],
+    };
+  }
+  pins["openai-agent"].models = codex;
+  return pins;
+}
+
+/** JSON with keys sorted at every level and no whitespace: one value, one string. */
+export function canonical(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical).join(",")}]`;
+  if (v && typeof v === "object") return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(",")}}`;
+  return JSON.stringify(v);
+}
+
+export function pinState(root) {
+  const pins = readPins(root);
+  return { digest: `sha256:${createHash("sha256").update(canonical(pins)).digest("hex")}`, pins, schema: SCHEMA };
+}
+
+if (isEntrypoint(import.meta.url)) {
+  const args = process.argv.slice(2);
+  let root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  if (args.length === 2 && args[0] === "--root") root = resolve(args[1]);
+  else if (args.length) {
+    process.stderr.write("usage: node scripts/engine-pins.mjs [--root <dir>]\n");
+    process.exit(2);
+  }
+  try {
+    process.stdout.write(`${canonical(pinState(root))}\n`);
+  } catch (e) {
+    if (!(e instanceof CouldNotLook)) throw e;
+    process.stderr.write(`engine-pins: could not look — ${e.message}\n`);
+    process.exit(2);
+  }
+}

package/scripts/release-bench-replay-check.mjs

@@ -0,0 +1,87 @@
+// 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-bench-replay-check.mjs — a cut waits while a moved engine pin has no passing bench replay.
+//
+//   node scripts/release-bench-replay-check.mjs [--since <tag>] [--head <ref>]    # reads REPO and GH_TOKEN
+//
+// The push workflow asks for a replay of saved cases whenever a push moves the engine pins
+// (bench-replay-request.mjs); the machine holding the cases answers with a `bench replay` status, pass or
+// flag. This is where that answer is read: before a beta or a stable is cut from HEAD, or from `--head`
+// when the checkout is not on the commit being cut (the dispatcher reads origin/main from its own checkout).
+//
+// WHAT IT COMPARES. The pins at HEAD against the pins at the last version cut (`--since`, by default the
+// newest `v*` tag HEAD contains), both judged by THIS checkout's rule. Equal pins: nothing to read. Moved
+// pins: the commits since that tag, on main's own line, whose pins equal HEAD's are the ones that carry
+// today's pins, and one of them must carry a passing `bench replay`.
+//
+// WHAT HOLDS THE CUT, and only one thing lets it through:
+//   pass on any of those commits ............ cut
+//   flag, and no pass ....................... held — fix it, or explain it on the change's issue and set pass by hand
+//   waiting, or no status at all ............ held — "not reported"; an absent answer is never a pass
+// The output names the commit and the state, never a count or a case: it is printed in a public log.
+//
+// Exit 0: nothing moved, or a replay passed. Exit 1: held. Exit 2: could not look.
+
+import { execFileSync } from "node:child_process";
+import { pinsAt, latestReplay, CONTEXT } from "./bench-replay-request.mjs";
+import { isEntrypoint } from "../shared/is-entrypoint.mjs";
+
+const git = (args) => execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+
+/**
+ * The verdict for a cut of `head` since `since`. PURE apart from the injected readers: `pins(commit)`
+ * returns a pin state or throws, `line()` lists the commits since `since` on main's own line, newest first,
+ * and `replay(sha)` returns the latest `bench replay` state or null.
+ */
+export async function verdict({ head, since, pins, line, replay }) {
+  const now = pins(head);
+  let then = null;
+  try { then = pins(since); } catch { /* could not tell: the replay must answer */ }
+  if (then && then.digest === now.digest) return { hold: false, why: `no engine pin moved since ${since}` };
+  const carrying = [];
+  for (const c of line()) {
+    let p = null;
+    try { p = pins(c); } catch { /* a commit the rule cannot read carries no answer */ }
+    if (!p || p.digest !== now.digest) break;   // older than the last move: its answer was for other pins
+    carrying.push(c);
+  }
+  const answers = [];
+  for (const c of carrying) answers.push({ sha: c, answer: await replay(c) });
+  const pass = answers.find((a) => a.answer?.state === "success");
+  if (pass) return { hold: false, why: `${CONTEXT}: ${pass.answer.description || "pass"} on ${pass.sha.slice(0, 12)}` };
+  const flag = answers.find((a) => a.answer?.state === "failure");
+  if (flag) return { hold: true, why: `${CONTEXT}: flagged on ${flag.sha.slice(0, 12)} — fix it, or explain it on the change's issue and set pass by hand` };
+  return { hold: true, why: `${CONTEXT}: not reported for the engine pins at ${String(head).slice(0, 12)}${answers.some((a) => a.answer) ? " (still waiting)" : ""}` };
+}
+
+if (isEntrypoint(import.meta.url)) {
+  const { REPO, GH_TOKEN } = process.env;
+  const args = process.argv.slice(2);
+  try {
+    if (!REPO || !GH_TOKEN) throw new Error("REPO and GH_TOKEN are required");
+    const opt = {};
+    for (let i = 0; i < args.length; i += 2) {
+      if (!["--since", "--head"].includes(args[i]) || args[i + 1] === undefined) throw new Error("usage: [--since <tag>] [--head <ref>]");
+      opt[args[i].slice(2)] = args[i + 1];
+    }
+    const head = git(["rev-parse", `${opt.head ?? "HEAD"}^{commit}`]);
+    const since = opt.since ?? git(["describe", "--tags", "--abbrev=0", "--match", "v*", head]);
+    const api = async (path) => {
+      const r = await fetch(`https://api.github.com/repos/${REPO}/${path}`,
+        { headers: { authorization: `Bearer ${GH_TOKEN}`, accept: "application/vnd.github+json" } });
+      if (!r.ok) throw new Error(`GET ${path}: ${r.status}`);
+      return r.json();
+    };
+    const v = await verdict({
+      head, since, pins: (c) => pinsAt(c),
+      line: () => git(["rev-list", "--first-parent", `${since}..${head}`]).split("\n").filter(Boolean),
+      replay: (sha) => latestReplay(api, sha),
+    });
+    console.log(`release-bench-replay-check: ${v.why}`);
+    process.exit(v.hold ? 1 : 0);
+  } catch (e) {
+    process.stderr.write(`release-bench-replay-check: could not look — ${e.message}\n`);
+    process.exit(2);
+  }
+}

package/scripts/settings-render-check.mjs

@@ -380,7 +380,6 @@ const signInProbe = `(() => {
 const out = {}
 const SPEC = {
   signInName: "Through your organisation's sign-in service",
-  webSearch: ['The engine’s own web search', 'provided by the engine', 'Available', 'The model searches the web itself during a run.'],
   categories: ['Trademark register', 'Common-law and marketplace research', 'Open-web search', 'Case law and oppositions'],
   caseLawGap: 'Until these are set up, a Full country search still runs and its report discloses the case-law gap instead of reporting no adverse case law.',
   adminLine: 'To change the address, the permissions or the companies on it, contact your Clearotron administrator.',
@@ -398,7 +397,9 @@ for (const theme of ['light', 'dark']) {
   // ── Installation settings
   console.log('\nInstallation settings:')
   loads.length = 0
-  if (await open('/portal/admin/config', "document.querySelectorAll('.cfg-row').length >= 10", 'Installation settings drew its rows')) {
+  // Nine rows: sign-in, the engine, and seven providers. The engine's own web search had a tenth; it is off on
+  // both engines and has no row.
+  if (await open('/portal/admin/config', "document.querySelectorAll('.cfg-row').length >= 9", 'Installation settings drew its rows')) {
     await setTheme(theme)
     const s = (await evalIn(settingsProbe)) ?? {}
     out[`settings-${theme}`] = s
@@ -411,12 +412,10 @@ for (const theme of ['light', 'dark']) {
       `the sign-in row reads "${SPEC.signInName} · Configured" (saw ${JSON.stringify(si)})`)
     ok(si && same(si.mono, [`auth-proxy · issuer ${ISSUER}`]), `the mode and issuer are the row's quiet mono line (saw ${JSON.stringify(si?.mono)})`)
     const rights = [...s.signIn, ...s.engine, ...s.categories.flatMap((c) => c.rows)].map((r) => r.stateRight)
-    ok(rights.length >= 10 && new Set(rights).size === 1, `every state lines up in one column (right edges ${JSON.stringify([...new Set(rights)])})`)
-    ok(s.engine.length === 2 && s.engine[0].name === 'Anthropic' && s.engine[0].state === 'Subscription',
-      `Engine carries the engine row first (saw ${JSON.stringify(s.engine[0])})`)
-    const web = s.engine[1]
-    ok(web && same([web.name, web.val, web.state, web.notes[0]], SPEC.webSearch),
-      `the engine's own web search sits under Engine, in the page's words (saw ${JSON.stringify(web)})`)
+    ok(rights.length >= 9 && new Set(rights).size === 1, `every state lines up in one column (right edges ${JSON.stringify([...new Set(rights)])})`)
+    ok(s.engine.length === 1 && s.engine[0].name === 'Anthropic' && s.engine[0].state === 'Subscription',
+      `Engine carries the engine row alone (saw ${JSON.stringify(s.engine)})`)
+    ok(!s.engine.some((r) => /web search/i.test(r.name)), "the engine's own web search, off on both engines, has no row under Engine")
     ok(same(s.categories.map((c) => c.label), SPEC.categories), `four provider categories, in order (saw ${JSON.stringify(s.categories.map((c) => c.label))})`)
     const repeated = s.categories.flatMap((c) => c.rows.filter((r) => [r.name, r.val ?? '', ...r.notes].some((t) => t.includes(c.label))).map((r) => `${c.label} on ${r.name}`))
     ok(repeated.length === 0, `no category name is repeated on a row (saw ${JSON.stringify(repeated)})`)