clearotron 0.4.1-beta.2 → 0.4.1-beta.4

package/.env.example

@@ -96,6 +96,15 @@ CLEAROTRON_CLAUDE_PATH=claude
 # the copied `.env`, not a choice).
 # effect: setup
 CLEAROTRON_CODEX_PATH=codex
+#
+# How long one tool answer may be before it is handed over in parts, in bytes, counted as a quoted string
+# (shared/answer-parts.mjs). Each engine gives every tool server its own size: 45,000 on Claude, because
+# Claude Code saves an answer longer than 50,000 characters to a file the model must read for itself, and
+# 36,000 on openai-agent, because Codex removes the middle of a tool read longer than about 39,000 bytes.
+# A smaller value here still applies on both; empty leaves the engine's size. The answer itself is
+# unchanged either way; the tool runs once, and a later part is read from the answer the server holds.
+# effect: tuning
+CLEAROTRON_TOOL_ANSWER_BYTES=
 
 CLEAROTRON_WORK_DIR=
 # Customer/project config store (loadProfiles). Unset ⇒ driver's built-in profiles dir.

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": "08583753fbde693fdecdc8e16f11781dae789f55",
-  "version": "0.4.1-beta.2"
+  "commit": "103da45d8abcbbe5af51cacd213954a3cc59c841",
+  "version": "0.4.1-beta.4"
 }

package/docs/architecture/04-configuration-reference.md

@@ -292,7 +292,8 @@ of truncations.
 
 | Var | Default | Meaning |
 |---|---|---|
-| `CLEAROTRON_BAND_RESPONSE_CHARS` | the shape-part size | Characters per band-server response. Floor 4096; defaults to whatever the shape part is set to, so raising one raises both unless this is set too. |
+| `CLEAROTRON_BAND_RESPONSE_CHARS` | five sixths of `CLEAROTRON_TOOL_ANSWER_BYTES`: 37,500 on the Claude engine, 30,000 on the OpenAI engine; 70,000 with no answer size | Characters per band-server response, the band summary's parts included; a summary part is never longer than 70,000 whatever this says. Floor 4096. The sixth left over is room for the quotes and line breaks a printout adds and for a banner, so a band answer is never split again into answer parts. On the OpenAI engine it is at most 30,000; a smaller value set here still applies. |
+| `CLEAROTRON_TOOL_ANSWER_BYTES` | 45,000 on the Claude engine, 36,000 on the OpenAI engine | Bytes per tool answer from every local tool server and the case-law bridge, counted as a quoted string (a quote or line break counts two). A longer answer is served in parts, each naming the next, and the tool runs once: a later part is read from the answer the server holds. Each engine writes its size into every server's entry: Claude Code saves an answer longer than 50,000 characters to a file the model must read for itself, and Codex removes the middle of a tool read longer than about 39,000 bytes. A smaller value set here still applies on both. A server started outside a stage, with no size, serves every answer whole. Floor 8192. |
 
 ### Surfaces beside the driver — portal, demo, e2e harness
 

package/driver/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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
+
+- Fixed: A crowded clearance on the Codex engine no longer stops before its report.
+
 ## 0.4.1-beta.2
 
 ### 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/band-server.mjs

@@ -20,6 +20,7 @@ import { readFileSync, readdirSync, appendFileSync, existsSync, mkdirSync } from
 import { join, dirname } from "node:path";
 import { driverDir } from "../../../shared/driver-dir.mjs";   //
 import { serve } from "./stdio-server.mjs";
+import { answerBudget } from "../../../shared/answer-parts.mjs";
 import { classifyRecord, prepareTargets, SHAPE_TIERS, isLiveRecord } from "../../band-shape.mjs";
 import { recordQids } from "../../named-band.mjs";
 import { normalizeRecordUri } from "../../registry-fidelity.mjs";
@@ -98,7 +99,8 @@ const loadJson = (p) => JSON.parse(readFileSync(p, "utf8"));
 // contract is honest and explicit: an over-size shape announces "part N/M" and names the next call;
 // the common single-part case is served verbatim with no banner. The part size was a test seam with a
 // floor under it so a misconfiguration could never shred the shape into confetti; step 3 deleted
-// the knob, and a constant cannot be misconfigured.
+// the knob, and a constant cannot be misconfigured. A smaller answer size still lowers it
+// (SHAPE_PART_SERVED, below), never under the answer size's own floor.
 const SHAPE_PART_CHARS = 70000;   // step 3 — was a knob; no environment ever set it
 
 // PR-11 — the SAME transport cap bounds the other two tools (they were shipped unbounded): a
@@ -106,7 +108,19 @@ const SHAPE_PART_CHARS = 70000;   // step 3 — was a knob; no environment ever
 // per-tool-output token cap and error the call — killing the reading path exactly where the record
 // volume is highest. band_lookup TRIMS records (the full match count always survives, with an
 // honest note); band_record serves PARTS like band_shape (a record is a document — never trimmed).
-const RESPONSE_CHARS = Math.max(4096, Number(process.env.CLEAROTRON_BAND_RESPONSE_CHARS) || SHAPE_PART_CHARS);
+// Given an answer size and no band size of its own, the band answers in five sixths of it: the rest is room
+// for the quotes and line breaks a printout adds (up to 13% on band answers) and for a banner, so a band
+// answer is never split a second time (shared/answer-parts.mjs). 37,500 on Claude, 30,000 on codex.
+const RESPONSE_CHARS = Math.max(4096, Number(process.env.CLEAROTRON_BAND_RESPONSE_CHARS)
+  || (answerBudget() ? Math.floor(answerBudget() / 1.2) : SHAPE_PART_CHARS));
+
+// The shape is split at the smaller of its own part size and the answer size, because codex cuts the
+// middle out of a read over about 39,000 bytes and is given a smaller answer size for that
+// (engine/mcp/codex-config.mjs, CODEX_BAND_ANSWER_CHARS). Measured in testing, 2026-10-11: a GPT model that
+// printed a 70,269-character shape part to read it named 11 of its 24 marker rows, and in one attempt of a
+// real run four of five shape reads were that long. Never larger than the constant,
+// so a larger answer size cannot push a part past Claude's limit; with no size set, nothing changes.
+const SHAPE_PART_SERVED = Math.min(SHAPE_PART_CHARS, RESPONSE_CHARS);
 
 /** Split text into parts of ≤ budget chars, cutting only at line boundaries (an over-budget single
  *  line still ships whole — never cut mid-line). Concatenating the parts with "\n" restores the
@@ -216,7 +230,7 @@ function bandShape(params) {
   if (!RUN_DIR) { logRead("band_shape", { format }, { ok: false }); return { isError: true, text: "ERROR: CLEAROTRON_BAND_RUN_DIR not set — band tools are wired per run by the driver." }; }
   if (!existsSync(p)) { logRead("band_shape", { format }, { ok: false }); return { isError: true, text: `ERROR: ${p} not found — the driver derives it after the register fan-in; if the band exists but the shape does not, report this as a driver defect (do NOT slice the raw band instead).` }; }
   const text = readFileSync(p, "utf8");
-  const parts = splitAtLines(text, SHAPE_PART_CHARS);
+  const parts = splitAtLines(text, SHAPE_PART_SERVED);
   const total = parts.length;
   if (total === 1) {                                    // the common case — served verbatim, no banner
     logRead("band_shape", { format }, { ok: true, bytes: text.length });
@@ -240,6 +254,11 @@ function bandLookup(params = {}) {
   try { band = loadJson(bandPath()); } catch (e) { logRead("band_lookup", params, { ok: false }); return { isError: true, text: `ERROR: band unreadable (${e.message}) — a driver-side defect; report it, never hand-repair the band.` }; }
   const { record_id, owner, nice_class, tier, qid, query, text, status, live_only = false } = params;
   const limit = Math.max(1, Math.min(Number(params.limit) || 20, 100));
+  // PAGING. A large band is read page by page from `offset`, in the band's own order, and a capped answer
+  // names the next offset. Without it the only way to see every record was to slice the band by owner or
+  // text fragments, and a seat told to judge the complete band read it many times over (1,423 records,
+  // 2,287 lookups, 65.8 MB, until the engine's output cap stopped the turn).
+  const offset = Math.max(0, Math.floor(Number(params.offset) || 0));
   if (tier && !SHAPE_TIERS.includes(tier)) return { isError: true, text: `ERROR: tier must be one of ${SHAPE_TIERS.join(" | ")}.` };
 
   // tier filtering classifies against the SHAPE's own frozen targets — same classifier, same result.
@@ -270,7 +289,7 @@ function bandLookup(params = {}) {
     if (text && !norm(r?.mark_text).includes(norm(text))) continue;
     if (prepared && classifyRecord(r?.mark_text, prepared).tier !== tier) continue;
     matched++;
-    if (hits.length < limit) hits.push(project(r));
+    if (matched > offset && hits.length < limit) hits.push(project(r));
   }
   // matching crowd descriptors ride along (a lookup that lands in an un-enumerated zone must SEE that).
   const crowds = (Array.isArray(band?.crowds) ? band.crowds : []).filter((c) => {
@@ -301,9 +320,10 @@ function bandLookup(params = {}) {
   // The full `matched` count always ships, and the note says exactly how many records were withheld.
   let byteCapped = 0;
   const body = () => JSON.stringify({
-    matched, returned: hits.length,
-    ...(matched > hits.length ? { note: `capped at ${hits.length} — narrow the filters${byteCapped ? "" : " (or raise limit ≤100)"} to see the rest; the count above is the full match` } : {}),
-    ...(byteCapped ? { byte_cap_note: `${byteCapped} matched record(s) withheld to fit one tool response — narrow the filters (owner / nice_class / tier / qid) and look them up in smaller slices` } : {}),
+    matched, returned: hits.length, ...(offset ? { offset } : {}),
+    ...(matched > offset + hits.length ? { next_offset: offset + hits.length } : {}),
+    ...(matched > offset + hits.length ? { note: `capped at ${hits.length} — call again with offset: ${offset + hits.length} for the next page; the count above is the full match` } : {}),
+    ...(byteCapped ? { byte_cap_note: `${byteCapped} matched record(s) withheld to fit one tool response — call again with offset: ${offset + hits.length} for the rest` } : {}),
     records: hits,
     ...(crowds.length ? { matching_crowds: crowds, crowd_note: "these matching slices were NOT enumerated — records under them may exist that no lookup can return; weigh the descriptor, never treat this result as their clean"
       + (refusedCrowds ? ` — and ${refusedCrowds} of them was/were NEVER ANSWERED at all (see "refusal"): no count exists for those, so they are unsearched rather than empty, and nothing about them can be read off a zero` : "")
@@ -405,11 +425,11 @@ serve({
     },
     {
       name: "band_lookup",
-      description: "Look up enumerated records in this run's frozen register band (read-only; logged to the reading audit). Filters AND together: record_id (exact uri), owner (substring), nice_class, tier (identical|near-identical|same-family|other|unclassifiable — classified against the shape's frozen targets), qid (exact plan-entry id — the plan-execution ledger join; a record surfaced by several slices matches under EVERY one of them), query (the _query slice that surfaced the record), text (substring of mark_text), status (substring), live_only, limit (default 20, max 100). Matching un-enumerated crowd descriptors ride along so a lookup can never mistake a counted-only zone for a clean.",
+      description: "Look up enumerated records in this run's frozen register band (read-only; logged to the reading audit). Filters AND together: record_id (exact uri), owner (substring), nice_class, tier (identical|near-identical|same-family|other|unclassifiable — classified against the shape's frozen targets), qid (exact plan-entry id — the plan-execution ledger join; a record surfaced by several slices matches under EVERY one of them), query (the _query slice that surfaced the record), text (substring of mark_text), status (substring), live_only, limit (default 20, max 100), offset (default 0: where in the matching records to start — a capped answer names the next offset, so a large band is read page by page). Matching un-enumerated crowd descriptors ride along so a lookup can never mistake a counted-only zone for a clean.",
       inputSchema: { type: "object", properties: {
         record_id: { type: "string" }, owner: { type: "string" }, nice_class: { type: "string" },
         tier: { type: "string", enum: SHAPE_TIERS }, qid: { type: "string" }, query: { type: "string" }, text: { type: "string" },
-        status: { type: "string" }, live_only: { type: "boolean" }, limit: { type: "number" },
+        status: { type: "string" }, live_only: { type: "boolean" }, limit: { type: "number" }, offset: { type: "number" },
       } },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       handler: bandLookup,

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

@@ -50,6 +50,30 @@ export const TOOL_SERVER_SETTINGS = Object.freeze([
   "OAUTH_BRIDGE_CREDS_DIR", "OAUTH_BRIDGE_CLIENT_NAME",
 ]);
 
+// CODEX CUTS THE MIDDLE OUT OF A LONG READ. It shows a model at most 10,000 tokens of the text a tool call
+// puts in front of it, from its start and its end, counting 4 bytes a token, with "…N tokens truncated…"
+// between them. For the GPT models, which call tools only from code (5.6 and 6.x), that text is what the
+// code prints, and a quoted print adds a byte for each quote and line break: up to 13% on real band answers.
+// Measured in testing, 2026-10-11, on codex 0.162.0 with gpt-6.1-sol: a model that printed a 68,752-character
+// band page to read it named 14 of its 30 records, and at 32,000 characters it named every one. The band
+// server sizes its answers for Claude's limit (70,000 characters, under 25,000 tokens). The vendor's settings
+// for a larger budget (`tool_output_token_limit`, a tool's `output_token_limit`) changed nothing on that
+// version, written in this file or given on the command line. So here the band server answers in 30,000
+// characters: printed with its escapes and banner it stays under the general answer size below, and so under
+// the cut. An install's own smaller size still wins.
+export const CODEX_BAND_ANSWER_CHARS = 30000;
+export const codexBandAnswerChars = (env = process.env) =>
+  Math.min(CODEX_BAND_ANSWER_CHARS, Number(env.CLEAROTRON_BAND_RESPONSE_CHARS) || CODEX_BAND_ANSWER_CHARS);
+
+// AND EVERY OTHER ANSWER: each server here, the case-law bridges and the page fetcher included, is given an
+// answer size, and an answer longer than that, counted as a quoted string, is served in parts, the tool
+// running once (shared/answer-parts.mjs). 36,000 bytes leaves room under the cut for the engine's own
+// wrapping (about 840 bytes); the band server's own answers stay under it and are never split again. An
+// install's own smaller size still wins.
+export const CODEX_TOOL_ANSWER_BYTES = 36000;
+export const codexToolAnswerBytes = (env = process.env) =>
+  Math.min(CODEX_TOOL_ANSWER_BYTES, Number(env.CLEAROTRON_TOOL_ANSWER_BYTES) || CODEX_TOOL_ANSWER_BYTES);
+
 // ── TOML value escaping (basic strings) ──────────────────────────────────────────────────────────────
 // One encoder for every TOML block the product writes; re-exported so this module's callers keep their import.
 export { tomlString };
@@ -121,7 +145,7 @@ export function webFetchRequested(allowedTools) {
 // stays the backstop. Absent/0/negative ⇒ emit nothing and leave codex's default alone, so this is inert
 // for any caller that does not thread a budget.
 export function renderCodexConfigToml({ mcpConfig, allowedTools, developerInstructions, nodeBin = process.execPath, credEnvForward = [...CRED_ENV_FORWARD, ...TOOL_SERVER_SETTINGS], toolTimeoutSec, fence = null, withheldFromCommands = [],
-  platform = process.platform } = {}) {
+  platform = process.platform, bandAnswerChars = codexBandAnswerChars(), toolAnswerBytes = codexToolAnswerBytes() } = {}) {
   const servers = parseClaudeMcpServers(mcpConfig);
   const enabled = enabledToolsByServer(allowedTools);
   const toolTimeout = Number(toolTimeoutSec) > 0 ? Math.floor(Number(toolTimeoutSec)) : undefined;
@@ -129,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 } = {}) => {
@@ -167,11 +199,15 @@ export function renderCodexConfigToml({ mcpConfig, allowedTools, developerInstru
     lines.push("");
   };
 
-  for (const [name, s] of Object.entries(servers)) emitServer(name, { ...s, enabledTools: enabled[name] }, { forwardCreds: true });
+  // Every server answers under codex's cut, the band server in its own way too (CODEX_TOOL_ANSWER_BYTES,
+  // CODEX_BAND_ANSWER_CHARS, above); `env` wins over a forwarded name.
+  const answers = { CLEAROTRON_TOOL_ANSWER_BYTES: String(toolAnswerBytes) };
+  for (const [name, s] of Object.entries(servers)) emitServer(name, { ...s, enabledTools: enabled[name],
+    env: { ...s.env, ...answers, ...(name === "band" ? { CLEAROTRON_BAND_RESPONSE_CHARS: String(bandAnswerChars) } : {}) } }, { forwardCreds: true });
 
   // WebFetch → the engine-local fetch server (codex has no built-in). Needs no creds (no env_vars).
   if (webFetchRequested(allowedTools))
-    emitServer("fetch", { command: nodeBin, args: [FETCH_SERVER], env: {}, enabledTools: ["fetch_url"] }, { forwardCreds: false });
+    emitServer("fetch", { command: nodeBin, args: [FETCH_SERVER], env: { ...answers }, enabledTools: ["fetch_url"] }, { forwardCreds: false });
 
   if (fence) lines.push(...fenceToml(fence));
   // ON WINDOWS, CODEX'S SANDBOX IS ON ONLY WHEN THIS NAMES IT. With no `[windows] sandbox` and no feature

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

@@ -834,9 +834,21 @@ function resolveGroup(group) {
   }
 }
 
+// CLAUDE'S ANSWER SIZE. Claude Code replaces a tool answer longer than 50,000 characters, or 25,000 tokens,
+// with a message naming a file it saved the answer to, and the model must read that file itself, the
+// first read refused when the file is past 25,000 tokens (the vendor's MCP page; measured in testing,
+// 2026-10-11, on 2.1.286 and 2.1.295: 49,159 characters arrived whole, 51,189 were replaced). So every
+// server is given this size, and a longer answer comes in the parts shared/answer-parts.mjs serves, the
+// banners the same on both engines. 45,000 bytes counted as a quoted string is under 50,000 characters, and
+// under 25,000 tokens for any text a register or a search returns. The codex config writes its own, smaller
+// size over this one (codex-config.mjs). An install's own smaller size still wins.
+export const CLAUDE_TOOL_ANSWER_BYTES = 45000;
+export const claudeToolAnswerBytes = (env = process.env) =>
+  Math.min(CLAUDE_TOOL_ANSWER_BYTES, Number(env.CLEAROTRON_TOOL_ANSWER_BYTES) || CLAUDE_TOOL_ANSWER_BYTES);
+
 // The mcp-config server env carries ONLY the per-run, non-secret values (session key + ledger paths +
-// agent + the run dir the band tools serve). Creds (CORSEARCH_SESSION_KEY / PERPLEXITY_API_KEY /
-// EUIPO_*) are inherited from the engine env.
+// agent + the run dir the band tools serve, and the answer size above). Creds (CORSEARCH_SESSION_KEY /
+// PERPLEXITY_API_KEY / EUIPO_*) are inherited from the engine env.
 function serverEnv({ sessionKey, agent, runDir, recordAxis }) {
   const e = {};
   // — see buildGatherMcpConfig: a register server without a run is refused there, so by the time
@@ -881,6 +893,7 @@ function serverEnv({ sessionKey, agent, runDir, recordAxis }) {
   if (runDir) e.CLEAROTRON_REGISTER_RECORD_LOG = runRecordLogPath(runDir);
   for (const v of ["CLEAROTRON_GATHER_SESSION_ID", "EUIPO_ENVIRONMENT"])
     if (process.env[v]) e[v] = process.env[v];
+  e.CLEAROTRON_TOOL_ANSWER_BYTES = String(claudeToolAnswerBytes());   // CLAUDE_TOOL_ANSWER_BYTES, above
   return e;
 }
 
@@ -935,6 +948,8 @@ export function buildGatherMcpConfig(groups = [], { sessionKey, agent, runDir, r
   if (runDir) auditEnv.CLEAROTRON_BAND_RUN_DIR = runDir;
   if (sessionKey) auditEnv.CLEAROTRON_GATHER_SESSION_KEY = sessionKey;
   if (agent) auditEnv.CLEAROTRON_GATHER_AGENT = agent;
+  // In a run, a fourth: the answer size, because a case-law answer is served in parts like any other.
+  if (Object.keys(auditEnv).length) auditEnv.CLEAROTRON_TOOL_ANSWER_BYTES = String(claudeToolAnswerBytes());
   for (const k of bridgeKeys) mcpServers[k] = { command: NODE, args: [BRIDGE, "--server", k], connectionTimeoutMs: 60000, ...(Object.keys(auditEnv).length ? { env: auditEnv } : {}) };
   return Object.keys(mcpServers).length ? { mcpServers } : null;
 }

package/driver/engine/mcp/perplexity-server.mjs

@@ -10,6 +10,7 @@ import { dirname, basename } from "node:path";
 import { driverDir } from "../../../shared/driver-dir.mjs";   //
 import { underStudioSegment } from "../../../shared/path-seps.mjs";   // Windows builds the path with "\"
 import { serve } from "./stdio-server.mjs";
+import { answerBudget } from "../../../shared/answer-parts.mjs";
 import {
   isKnownPreset, questionPresetFor, buildRequestBody, callAgentAPI, formatResponse, formatSandboxResponse,
   validateGridSpec, buildGridProgramTask, captureGridFromResponse, requiredLedgerRefusal,
@@ -194,7 +195,10 @@ function tellObligations(spec, ledgerJson) {
 // and a grid's candidates grow with its results per cell. So they are served in parts, split between
 // cells, as band_shape serves an oversize shape, with the same part size. A later part is read from the
 // saved ledger: nothing is searched again.
-const GRID_PART_CHARS = 70000;
+// Smaller when this server was given an answer size (codex cuts the middle out of a longer read;
+// shared/answer-parts.mjs): three quarters of it, which leaves room for the rest of the reply and for the
+// quotes and line breaks a printout adds, so a part of the grid is never split again on its way to the model.
+const GRID_PART_CHARS = answerBudget() ? Math.min(70000, Math.floor(answerBudget() * 0.75)) : 70000;
 
 // `reserve` is what part 1's reply also carries (the meaning obligations): part 1 is that much smaller,
 // and every call passes the same reserve for the same ledger, so every call splits it the same way.

package/driver/engine/mcp/stdio-server.mjs

@@ -12,6 +12,7 @@ import { createInterface } from "node:readline";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { driverDir } from "../../../shared/driver-dir.mjs";   //
+import { answerBudget, answerPieces, servedPart, partNotHeld, takePart, heldAnswers, withAnswerPart } from "../../../shared/answer-parts.mjs";
 
 // ── half 2 — THE TOOL CALL LOG, so a killed call is a FACT and not an inference ────────────────
 //
@@ -88,6 +89,10 @@ export function serve({ name, version = "0.1.0", tools = [] }) {
   // reader must key on (server, seq) and never on seq alone.
   let callSeq = 0;
   const byName = new Map(tools.map((t) => [t.name, t]));
+  // A LONG ANSWER IS SERVED IN PARTS when this server was given an answer size (shared/answer-parts.mjs):
+  // the handler runs once, the answer is held here, and a later part is read from it. No size, no change.
+  const budget = answerBudget();
+  const held = heldAnswers();
   // ── — THE ANNOTATIONS TRAVEL, BECAUSE A TOOL MUST BE ABLE TO SAY WHAT IT DOES ──
   //
   // This line used to pick three fields and drop the rest, so a tool that declared `annotations` had
@@ -117,9 +122,10 @@ export function serve({ name, version = "0.1.0", tools = [] }) {
   // convenience — the exact thing annotations exist to prevent.
   // Listed when asked, not at start: a tool may give the schema for the run it serves (`schemaNow`), read
   // at call time like every per-run read here. A tool without one lists its declared schema, as before.
+  const schemaOf = (t) => (typeof t.schemaNow === "function" ? t.schemaNow(t.inputSchema) : t.inputSchema);
   const list = () => tools.map((t) => ({
     name: t.name, description: t.description,
-    inputSchema: typeof t.schemaNow === "function" ? t.schemaNow(t.inputSchema) : t.inputSchema,
+    inputSchema: budget ? withAnswerPart(schemaOf(t)) : schemaOf(t),
     ...(t.annotations ? { annotations: t.annotations } : {}),
   }));
   const send = (m) => process.stdout.write(JSON.stringify(m) + "\n");
@@ -144,11 +150,20 @@ export function serve({ name, version = "0.1.0", tools = [] }) {
       } else if (method === "tools/call") {
         const tool = byName.get(params?.name);
         if (!tool) return ok(id, { isError: true, content: [{ type: "text", text: `unknown tool: ${params?.name}` }] });
+        // A later part of a held answer is read from it, and the tool does not run: no started/settled pair,
+        // one row of its own, so a count of the tool's runs stays a count of its runs.
+        const { args, part } = budget ? takePart(params?.arguments) : { args: params?.arguments, part: null };
+        const kept = part ? held.get(tool.name, args) : null;
+        if (part && (kept || part > 1)) {
+          logToolEvent({ event: "answer-part", server: name, tool: tool.name, part, ...(kept ? { of: kept.length } : { held: false }) });
+          return ok(id, kept ? { content: [{ type: "text", text: servedPart(tool.name, kept, part) }] }
+            : { isError: true, content: [{ type: "text", text: partNotHeld(tool.name, part) }] });
+        }
         // — STAMPED BEFORE THE WORK, settled after it, and the pair is the whole mechanism. A
         // process killed mid-call cannot write anything, so "started with no settled" is the only shape
         // that can record a call that never returned.
         const seq = ++callSeq;
-        const axis = typeof params?.arguments?.axis === "string" ? params.arguments.axis : null;
+        const axis = typeof args?.axis === "string" ? args.axis : null;
         logToolEvent({ event: "started", seq, server: name, tool: tool.name, ...(axis ? { axis } : {}) });
         // ── — THE ONE SEAM EVERY TYPED CALL PASSES THROUGH ───────────────────────
         //
@@ -157,7 +172,7 @@ export function serve({ name, version = "0.1.0", tools = [] }) {
         // re-check by hand, which made "this field is required" a property of one author's diligence
         // rather than of the contract. The refusal names the fields in the acceptors' own token shape so
         // a seat can act on it in the turn it happens.
-        const unmet = requiredFieldViolations(tool.inputSchema, params?.arguments);
+        const unmet = requiredFieldViolations(tool.inputSchema, args);
         if (unmet.length) {
           // THE REASON THE ROW HAD IN SCOPE AND THREW AWAY. A settled row with
           // `ok: false` and nothing else asserts a failure and withholds everything that would let a
@@ -177,7 +192,7 @@ export function serve({ name, version = "0.1.0", tools = [] }) {
             + `${unmet.length === 1 ? "it" : "them"}. Send the field itself, not null and not a placeholder.` }] });
         }
         let out;
-        try { out = await tool.handler(params?.arguments || {}); }
+        try { out = await tool.handler(args || {}); }
         catch (e) {
           // A THROWN tool error SETTLES. It returned an answer — a wrong one, but the model saw it and
           // could act on it. Recording it as unsettled would attribute a live failure to a timeout. The
@@ -193,6 +208,11 @@ export function serve({ name, version = "0.1.0", tools = [] }) {
         const code = isError ? complaintCode(text) : null;
         logToolEvent({ event: "settled", seq, server: name, tool: tool.name, ...(axis ? { axis } : {}), ok: !isError,
           ...(isError ? { failure: "server", ...(code ? { reason: code } : {}) } : {}) });
+        const pieces = budget && !isError ? answerPieces(text, budget, tool.name) : null;
+        if (pieces && pieces.length > 1) {
+          held.hold(tool.name, args, pieces);
+          return ok(id, { content: [{ type: "text", text: servedPart(tool.name, pieces, 1) }] });
+        }
         ok(id, { isError: isError || undefined, content: [{ type: "text", text }] });
       } else if (id != null) {
         err(id, -32601, `method not found: ${method}`);

package/driver/package.json

@@ -2,7 +2,7 @@
   "name": "clearotron-driver",
   "private": true,
   "type": "module",
-  "version": "0.4.1-beta.2",
+  "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": {