clearotron 0.5.0-beta.0 → 0.5.0-beta.1

package/build-info.json

@@ -1,4 +1,4 @@
 {
-  "commit": "e2212d67aeaa269f95682ab906b16c03d37ffab4",
-  "version": "0.5.0-beta.0"
+  "commit": "39f3bdc47543630a4f206ac667aa0fd923a2b32b",
+  "version": "0.5.0-beta.1"
 }

package/driver/CHANGELOG.md

@@ -1,5 +1,14 @@
 # clearotron-driver
 
+## 0.5.0-beta.1
+
+### Patch Changes
+
+- Fixed: A search with more similar marks than can be read now narrows step by step, and stops once the lists it has read answer it. Before, it could keep searching far past what the advice needed.
+- Fixed: A crowded search that the lists already read have answered no longer appears among the report's coverage limits. Its count is still recorded.
+- For operators: A clearance now stops asking further follow-up searches after 120, and delivers its report with what it has read.
+- For operators: On the Signa register, follow-up searches now send spellings as lists, so a clearance makes fewer requests.
+
 ## 0.5.0-beta.0
 
 ### Minor Changes

package/driver/ask-ledger.mjs

@@ -54,6 +54,7 @@
 // DRIVER's instructed values appear in the model's frame, where this checks the MODEL's quote
 // appears in a driver-held file. Same expression, different question; it stays separate.
 import { squash } from "./doubt-ledger.mjs";
+import { OUTSTANDING_REASON } from "../providers/_shared/follow-up-searches.mjs";
 //
 // Ask record shape (frozen — _driver/asks.json and the audit's Ask Ledger both render it):
 //   {
@@ -469,7 +470,9 @@ export function deriveAsks({
       // must show it working. So EVERY rejection attempts the join, and one that did not mint later
       // ends OPEN — a real unanswered question the closure stage settles with a citation or that ships
       // visibly. "judged-immaterial" is reserved for a materiality judgment somebody actually made.
-      const supersededBy = mintedByIdentity.get(proposalIdentity(r?.proposal)) ?? null;
+      // A follow-up the run's safety net did not send is never superseded: the identity join ignores the regions, so a
+      // question minted for one market would otherwise bury the same question refused for another.
+      const supersededBy = issue === OUTSTANDING_REASON ? null : (mintedByIdentity.get(proposalIdentity(r?.proposal)) ?? null);
       push({
         ask_id: `ask:supplemental-rejected:${slug(axis)}:${i + 1}`,
         born: { place: "supplemental-proposal", artifact: `register-units/${axis}-supplemental-plan.json`, ref: `rejected[${i}]`, ts: r?.ts ?? null },

package/driver/band-shape.mjs

@@ -830,7 +830,7 @@ export function bandGroups(records, { classify, inScope, goods = null, dominantT
  *                             (charter P2d); the band itself stays per-registration
  * @returns { shape, md }      deterministic — same band + inputs ⇒ same bytes (no timestamps)
  */
-export function buildBandShape(band, { targets = [], inScopeClasses = [], crowdContext = null, caps = {}, positions = null, goods = null, goodsTest = null, goodsWordCount = 0, dominantTerm = "", manifestDominant = "", keysOf = null, markets = [], territories = [], evidenceOf = null } = {}) {
+export function buildBandShape(band, { crowdNarrowing = [], targets = [], inScopeClasses = [], crowdContext = null, caps = {}, positions = null, goods = null, goodsTest = null, goodsWordCount = 0, dominantTerm = "", manifestDominant = "", keysOf = null, markets = [], territories = [], evidenceOf = null } = {}) {
   const prepared = prepareTargets(Array.isArray(targets) && targets.every(isPrepared) ? targets.map((t) => t.text) : targets);
   const records = Array.isArray(band?.enumerated) ? band.enumerated : [];
   const crowds = Array.isArray(band?.crowds) ? band.crowds : [];
@@ -914,8 +914,11 @@ export function buildBandShape(band, { targets = [], inScopeClasses = [], crowdC
   // context slice joins a crowd when one of its terms appears in the crowd's query (case-folded).
   const ccSlices = Array.isArray(crowdContext?.slices) ? crowdContext.slices : [];
   const fold = (s) => foldDiacritics(String(s ?? "")).toLowerCase();
+  // what was retrieved under each crowd (register-plan.mjs, crowdNarrowing): data on the descriptor, by its qid
+  const endingByQid = new Map((Array.isArray(crowdNarrowing) ? crowdNarrowing : []).filter((r) => r?.qid && r?.narrowing).map((r) => [String(r.qid), r]));
   const shapeCrowds = crowds.map((c) => {
     const q = fold(c.query);
+    const end = c.qid ? endingByQid.get(String(c.qid)) : null;
     const joined = ccSlices
       .filter((s) => (Array.isArray(s.terms) ? s.terms : []).some((t) => fold(t) && q.includes(fold(t))))
       .map((s) => ({ unit: s.unit ?? null, axis: s.axis ?? null, terms: s.terms ?? [],
@@ -929,6 +932,7 @@ export function buildBandShape(band, { targets = [], inScopeClasses = [], crowdC
       // executor and judgment, and dropping them here would undo the first carry silently.
       ...(c.error === true ? { error: true } : {}),
       ...(c.deferred === true ? { deferred: true } : {}),
+      ...(end ? { narrowing: end.narrowing, ...(end.lists?.length ? { lists: end.lists } : {}), ...(end.not_covered?.length ? { not_covered: end.not_covered } : {}) } : {}),
       crowd_context_slice: joined.length ? joined : null,
     };
   });

package/driver/contract-vocabulary.mjs

@@ -530,9 +530,9 @@ export const INNER_CODES = Object.freeze([
   // ONE CODE, TWO TOKENS, and the split is by `cause` rather than by code: verify.mjs peels the
   // `axis_invalid` cause into its own family before counting the rest. A ruling naming only
   // `coverage_no_status` would be true of most `no_status` records and false of the ones that matter most.
-  { code: "no_status", mints: ["driver/coverage-form.mjs:897"], rollsUpTo: ["coverage_no_status", "coverage_form_axis_invalid"],
+  { code: "no_status", mints: ["driver/coverage-form.mjs:907"], rollsUpTo: ["coverage_no_status", "coverage_form_axis_invalid"],
     why: "Two composites, split on the record's `cause`: coverageFormFail() in verify.mjs for cause `axis_invalid`, and the same function for the rest. NOT the `@returns` annotation of findCoverageFormViolations() in coverage-form.mjs — that is the annotation, not the mint." },
-  { code: "engine_vocabulary", mints: ["driver/coverage-form.mjs:887"], rollsUpTo: ["coverage_form_engine_vocabulary"],
+  { code: "engine_vocabulary", mints: ["driver/coverage-form.mjs:897"], rollsUpTo: ["coverage_form_engine_vocabulary"],
     why: "#669 — the seat wrote an engine token into the `reason` sentence that reaches the reader's page. Checked on settled rows too, because a row the seat considers finished is exactly the one whose sentence gets printed. Namespaced by coverageFormFail() in verify.mjs; the bare code names a row, never a stage." },
 
   // ── ONE CODE, TWO MODULES ────────────────────────────────────────────────────────────────────────
@@ -544,7 +544,7 @@ export const INNER_CODES = Object.freeze([
   // failure tokens" already states the rule this row records: `coverage_form_damaged`, never a bare
   // `form_damaged`.
   { code: "form_damaged",
-    mints: ["driver/connotation-search.mjs:2002", "driver/connotation-search.mjs:2078", "driver/coverage-form.mjs:879"],
+    mints: ["driver/connotation-search.mjs:2002", "driver/connotation-search.mjs:2078", "driver/coverage-form.mjs:889"],
     rollsUpTo: ["connotation_form_damaged", "coverage_form_damaged"],
     why: "Minted in two lanes and namespaced per lane: connotationDispositionFail() in verify.mjs for the meaning sweep, coverageFormFail() in verify.mjs for the register digest. The namespacing is what keeps them apart — see verify.mjs's block headed \"the register coverage-form failure tokens\"." },
 ]);

package/driver/coverage-form-io.mjs

@@ -149,7 +149,8 @@ export function coverageFormInput(runDir) {
   const orderedTerritories = Array.isArray(plan.ordered_jurisdictions) ? plan.ordered_jurisdictions : [];
   return { input: { skeleton: exec.skeleton, plan, bandBlocksByAxis, deferredReasons, activeAxes,
     bandsUnreadable, orderedTerritories, capabilities, unknownAxisUnits,
-    awaiting: Array.isArray(exec.awaiting) ? exec.awaiting : [], withheld: readWithheldFamilies(runDir) }, absent: null };
+    awaiting: Array.isArray(exec.awaiting) ? exec.awaiting : [], withheld: readWithheldFamilies(runDir),
+    mainMarkets: Array.isArray(exec.main_markets) ? exec.main_markets : [] }, absent: null };
 }
 
 /**

package/driver/coverage-form.mjs

@@ -31,7 +31,7 @@
 import { REGISTER_AXES, COVERAGE_STATUSES, normalizeAxis, CROWD_RULING_TOKEN,
   CROWD_RULING_UNIT_GRAMMAR } from "./coverage-ledger.mjs";
 import { shortId } from "./connotation-search.mjs";
-import { openBlocksByAxis } from "./register-plan.mjs";
+import { openBlocksByAxis, crowdNarrowing, blocksByQidOf } from "./register-plan.mjs";
 import { territoryLayerReport, unsearchedLayerReason } from "./binding-layers.mjs"; import { goodsTermsList } from "../providers/_shared/term-shape.mjs";
 
 const STATUS_SET = new Set(COVERAGE_STATUSES);
@@ -344,8 +344,17 @@ export function blockOpenBecause(b, narrowings = []) {
  */
 export function coverageFormRows({ skeleton = [], activeAxes = null, plan = null,
   bandBlocksByAxis = {}, deferredReasons = {}, bandsUnreadable = [],
-  orderedTerritories = [], capabilities = null, awaiting = [], withheld = {} } = {}) {
+  orderedTerritories = [], capabilities = null, awaiting = [], withheld = {}, mainMarkets = [] } = {}) {
   const skel = Array.isArray(skeleton) ? skeleton.filter((s) => s && typeof s === "object") : [];
+  // WHAT WAS RETRIEVED UNDER EACH CROWD (register-plan.mjs, crowdNarrowing), worked out from the same blocks these rows
+  // are built from and carried on its row as data: a narrowed list retrieved in full (and which), none, or for the
+  // identical mark whether retrieved lists cover every class in every main market (and the cells they do not). The
+  // row stays open either way: reading the lists and deciding the crowd are the reading step's.
+  const narrowingByQid = new Map(crowdNarrowing(plan, blocksByQidOf(bandBlocksByAxis), { mainMarkets }).rows.map((r) => [String(r.qid), r]));
+  const endingOf = (qid) => {
+    const r = narrowingByQid.get(String(qid));
+    return r ? { narrowing: r.narrowing, ...(r.lists?.length ? { lists: r.lists } : {}), ...(r.not_covered?.length ? { not_covered: r.not_covered } : {}) } : {};
+  };
   const entriesByQid = new Map((plan?.entries ?? []).map((e) => [e.qid, e]));
   const open = openBlocksByAxis(skel, bandBlocksByAxis, plan);
   // Axis order is the run's, not a set's iteration order: the plan-execution skeleton first (the order
@@ -393,6 +402,7 @@ export function coverageFormRows({ skeleton = [], activeAxes = null, plan = null
         ...(Number.isInteger(b.total_hits) ? { total_hits: b.total_hits } : {}),
         ...(b.unaccounted?.length ? { unaccounted_terms: b.unaccounted } : {}),
         ...(b.unaccounted_classes?.length ? { unaccounted_classes: b.unaccounted_classes } : {}),
+        ...endingOf(b.qid),
         // The block's OWN row is the naming the deleted join required. A clean claim HERE is the
         // silent swallow; a clean claim on a sibling slice never discharged this block and does not now.
         open: true,
@@ -1034,6 +1044,8 @@ function briefRow(r) {
     r.unaccounted_classes?.length ? `classes unaccounted: ${r.unaccounted_classes.join(", ")}` : "",
     r.unaccounted_terms?.length ? `terms unaccounted: ${r.unaccounted_terms.join(", ")}` : "",
     r.receipt_reason ? `receipt: ${String(r.receipt_reason).slice(0, 160)}` : "",
+    // what was retrieved under the crowd (register-plan.mjs, crowdNarrowing), as data beside the counts it rests on
+    r.narrowing ? `narrowing: ${r.narrowing}${r.lists?.length ? ` (${r.lists.slice(0, 6).join(", ")})` : ""}${r.not_covered?.length ? `; not covered: ${r.not_covered.slice(0, 12).join(", ")}` : ""}` : "",
   ].filter(Boolean).join("; ");
   const settled = String(r.status ?? "").trim() ? ` [settled: ${String(r.status).trim()}]` : "";
   return `  ${r.row_id}  (${r.kind}) ${r.unit}${facts ? ` — ${facts}` : ""}${r.open === true ? " — OPEN: never confirmed-clean" : ""}${settled}`;

package/driver/effective-scope.mjs

@@ -192,19 +192,24 @@ export function orderTerritories(job, profile) {
 /**
  * THE NARROWING ORDER, as the register reading step is told it (ruled 2026-09-26): goods and class
  * first, then the markets in turn, with the markets the driver knows filled in. One line. PURE.
+ *
+ * ONE MARKET LIST, the one that applies: the order's countries; else the customer's priority markets; else the
+ * markets the customer's field and brand point to, with the major markets as their fallback. The line used to
+ * print all three as a chain of "else", and the reading step was left to pick among them. Each step keeps the
+ * limits before it, and a crowd still a crowd after the markets is recorded with its count: the narrowing ends.
  */
 export function narrowingOrderLine(job, profile, inScopeClasses = null) {
   const { scope, priorities, major } = narrowingMarkets(job, profile);
   const markets = scope.length
     ? `one question per market of the order's scope (${scope.join(", ")}); nothing outside it was ordered`
-    : `one question per market: ${[
-      priorities.length ? `the customer's priority markets (${priorities.join(", ")})` : "",
-      "the markets the customer's field and brand point to (judge them from the matter frame)",
-      `the major markets (${major.join(", ")})`,
-    ].filter(Boolean).join(", else ")}`;
+    : priorities.length
+      ? `one question per market: the customer's priority markets (${priorities.join(", ")})`
+      : `one question per market: the markets the customer's field and brand point to (judge them from the matter frame), else the major markets (${major.join(", ")})`;
   return `NARROWING A CROWD, in this order: first the goods and the classes, the client's goods words in `
-    + `${inScopeClasses ? `the order's classes [${inScopeClasses}]` : "the order's classes"}, then one of those classes at a time; `
-    + `still a crowd, then the markets, ${markets}. From the narrowed lists, read what a lawyer would raise. `
+    + `${inScopeClasses ? `the order's classes [${inScopeClasses}]` : "the order's classes"}, then one of those classes at a time, `
+    + `each step keeping the limits before it and stopping at the first list you can read; `
+    + `still a crowd, then the markets, ${markets}. Still a crowd after the markets: record it with its count. `
+    + `From the narrowed lists, read what a lawyer would raise. `
     + `What was counted and not read stays on its coverage row with its count: set aside, never clean.`;
 }
 

package/driver/engine/mcp/held-answers.mjs

@@ -0,0 +1,128 @@
+// 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
+//
+// held-answers.mjs — ONE ANSWER PER QUESTION PER RUN, ACROSS EVERY WORKER AND PASS.
+//
+// The register workers run in parallel and do not see each other's questions, so the same question was put to the
+// register again by another worker: on a test run of a crowded matter, 178 follow-up proposals held 167 distinct
+// questions, and the 11 copies cost 49 calls. A question the run has already answered now gets the held answer, and
+// one the run has already decided not to ask (a family withheld by judgment, or a follow-up the run's safety net
+// refused) gets that decision. Nothing is asked again and no call is made.
+//
+// WHAT MAKES TWO QUESTIONS THE SAME: every field that changes what the register is asked — the predicate, the term
+// or terms, their romanised forms, the classes, the markets, the goods words, the owner and the kind of answer —
+// and none that only records where a question came from. A question with no markets is asked to the plan's, so it
+// is the same as one naming them. Owner names are compared as written, never merged. A different scope is a
+// different question, and an earlier answer that failed is no answer: both are asked again.
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { driverDir } from "../../../shared/driver-dir.mjs";
+import { OUTSTANDING_REASON } from "../../../providers/_shared/follow-up-searches.mjs";
+import { awaitsReadingTurn } from "../../../providers/_shared/plan-guards.mjs";
+import { releasedFamilyQids } from "../../withheld-families.mjs";
+
+const QUESTION_FIELDS = ["predicate", "term", "terms", "romanizedTerms", "term_literal", "nice_classes", "regions", "goods_text", "owner", "expected_kind"];
+const sorted = (v) => [...v].map((x) => String(x)).sort();
+
+/** The question an entry asks, as a key. `planRegions` fills an entry that names no markets. PURE. */
+export function questionKey(e, planRegions = []) {
+  const o = {};
+  for (const k of QUESTION_FIELDS) {
+    let v = e?.[k];
+    if (k === "predicate") v = String(v ?? "default");
+    if (k === "expected_kind") v = String(v ?? "enumerate");
+    if (k === "regions" && !(Array.isArray(v) && v.length)) v = planRegions;
+    if (v === undefined || v === null || v === false || (Array.isArray(v) && !v.length) || v === "") continue;
+    o[k] = Array.isArray(v) ? (k === "terms" || k === "romanizedTerms" ? v.map(String) : sorted(v)) : v;
+  }
+  return JSON.stringify(o);
+}
+
+// A band file is read once per change: the propose tool is called many times in a turn, and a primary sweep's band
+// runs to tens of megabytes. Keyed on the path, its size and its modification time. Only what a held answer hands
+// back is kept, the first records among it, so a worker's process does not hold every band whole.
+const BAND_CACHE = new Map();
+const HELD_RECORDS = 25;
+function readBlocks(path) {
+  let st;
+  try { st = statSync(path); } catch { return []; }
+  const stamp = `${st.size}:${st.mtimeMs}`;
+  const hit = BAND_CACHE.get(path);
+  if (hit && hit.stamp === stamp) return hit.blocks;
+  let blocks = [];
+  try {
+    const j = JSON.parse(readFileSync(path, "utf8"));
+    blocks = (Array.isArray(j) ? j : []).filter((b) => b?.qid).map((b) => ({
+      qid: b.qid, state: b.state ?? null, error: b.error === true, total_hits: b.total_hits ?? null,
+      count: b.count ?? (Array.isArray(b.records) ? b.records.length : null),
+      records: Array.isArray(b.records) ? b.records.slice(0, HELD_RECORDS) : [],
+    }));
+  } catch { blocks = []; }
+  BAND_CACHE.set(path, { stamp, blocks });
+  return blocks;
+}
+
+/**
+ * Refuse the minted entries whose question the run has already answered on another row, the way the fold refuses a
+ * question the plan already holds: `duplicate-question`, with the row that answered it as the twin. Second framing's
+ * re-sweep calls this before its fold, because the fold sees only the plan's rows on the re-sweep's own axis, and a
+ * question another worker answered is not asked again. Only an answer settles: a withheld family has its own refusal,
+ * and a follow-up the safety net did not send would not be sent again. PURE.
+ * @returns {{ kept: object[], refused: {qid: string, term: string, kind: "duplicate-question", twin: string}[] }}
+ */
+export function refuseHeldQuestions(entries, held, planRegions = []) {
+  const kept = [], refused = [];
+  for (const e of Array.isArray(entries) ? entries : []) {
+    const h = held?.get?.(questionKey(e, planRegions));
+    if (e?.qid && h?.decision === "answered" && h.qid && String(h.qid) !== String(e.qid))
+      refused.push({ qid: e.qid, term: String(e.term ?? e.terms?.[0] ?? ""), kind: "duplicate-question", twin: String(h.qid) });
+    else kept.push(e);
+  }
+  return { kept, refused };
+}
+
+/**
+ * The run's held answers and decisions, by question key. IMPURE (reads the run's register files).
+ * @returns {Map<string, { qid: string, axis: string, decision: "answered"|"withheld"|"outstanding", block?: object }>}
+ */
+export function heldAnswers(runDir, { planRegions = [], withheld = {}, released = null } = {}) {
+  // A FAMILY WAITING FOR THE READING TURN IS ANSWERED ONLY ONCE IT IS RELEASED AND RUN, the plan join's own rule: until
+  // then it was not asked, whatever block its qid may carry, and a question repeating it is asked as the join expects.
+  let releasedQids = released;
+  if (!(releasedQids instanceof Set)) { try { releasedQids = releasedFamilyQids(runDir); } catch { releasedQids = new Set(); } }
+  const held = new Map();
+  const units = join(runDir, "register-units");
+  const blocksByQid = new Map();
+  const plans = [];
+  try { plans.push({ axis: null, plan: JSON.parse(readFileSync(driverDir(runDir, "register-plan.json"), "utf8")) }); } catch { /* no frozen plan */ }
+  let files = [];
+  try { files = readdirSync(units); } catch { files = []; }
+  for (const f of files) {
+    if (f.endsWith("-band.json")) for (const b of readBlocks(join(units, f))) if (b?.qid) blocksByQid.set(String(b.qid), b);
+    if (f.endsWith("-supplemental-plan.json")) {
+      try { plans.push({ axis: f.slice(0, -"-supplemental-plan.json".length), plan: JSON.parse(readFileSync(join(units, f), "utf8")) }); } catch { /* torn: skipped */ }
+    }
+  }
+  for (const { plan } of plans) {
+    for (const e of Array.isArray(plan?.entries) ? plan.entries : []) {
+      if (!e?.qid) continue;
+      const key = questionKey(e, planRegions);
+      if (held.has(key)) continue;
+      if (awaitsReadingTurn(e.when) && !releasedQids.has(String(e.qid))) {
+        if (withheld?.[e.qid]) held.set(key, { qid: e.qid, axis: e.axis, decision: "withheld" });
+        continue;
+      }
+      const b = blocksByQid.get(String(e.qid));
+      if (b && b.error !== true) held.set(key, { qid: e.qid, axis: e.axis, decision: "answered", block: b });
+      else if (withheld?.[e.qid]) held.set(key, { qid: e.qid, axis: e.axis, decision: "withheld" });
+    }
+    // A follow-up the run's safety net did not send is a decision too: proposed again, it would not be sent again.
+    for (const r of Array.isArray(plan?.rejected) ? plan.rejected : []) {
+      if (r?.issue !== OUTSTANDING_REASON || !r?.proposal) continue;
+      const key = questionKey(r.proposal, planRegions);
+      if (!held.has(key)) held.set(key, { qid: null, axis: null, decision: "outstanding" });
+    }
+  }
+  return held;
+}

package/driver/engine/mcp/supplemental.mjs

@@ -32,10 +32,18 @@
 import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { driverDir } from "../../../shared/driver-dir.mjs";   //
-import { PLAN_PREDICATES, PLAN_MAX_OR_WIDTH, PLAN_MAX_NAME_LENGTH, fingerprint, ownerIntersectionGap, goodsTextGap, resolveRegions, houseElementOf, withoutHouseElementTerms, containsFormSubstitution } from "../../register-plan.mjs";
+import { PLAN_PREDICATES, PLAN_MAX_OR_WIDTH, PLAN_MAX_NAME_LENGTH, planExactOrWidth, planPhoneticOrWidth, fingerprint, ownerIntersectionGap, goodsTextGap, resolveRegions, houseElementOf, withoutHouseElementTerms, containsFormSubstitution } from "../../register-plan.mjs";
 import { entryTermIssues } from "../../../providers/_shared/term-shape.mjs";
+import { OUTSTANDING_REASON } from "../../../providers/_shared/follow-up-searches.mjs";
+import { heldAnswers, questionKey } from "./held-answers.mjs";
+import { readWithheldFamilies } from "../../withheld-families.mjs";
 import { isNonLatinTerm, romanizationRefusal, romanizationSpellings, nativeScriptIndexGap } from "../../../providers/_shared/script-form.mjs";
 
+// THE ONE SENTENCE THE MODEL READS WHEN THE RUN'S SAFETY NET HOLDS A FOLLOW-UP BACK (follow-up-searches.mjs). It names
+// no limit and no cost: the model is never told of the net. It rides the reply whenever a question was not sent, now
+// or by an earlier decision held for the run.
+export const OUTSTANDING_NOTE = "Not asked in this run. Keep it as an open question with your reason, and continue with what you have read.";
+
 const slug = (s) => String(s ?? "").toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "q";
 
 const PREVIEW_FIELDS = ["record_id", "mark_text", "classes", "status", "owner_name", "owner_country", "screen_verdict"];
@@ -57,17 +65,20 @@ const compactProposal = (p) => ({
 const inPriority = (p, prio) =>
   (Array.isArray(p?.nice_classes) ? p.nice_classes : []).some((c) => prio.has(String(c).trim()));
 
-// A SOUND-ALIKE BATCH GOES AS LISTS where the register takes one (`phoneticOrWidth`, ruled 2026-10-09): up to
-// that many spellings per question, within its word budget, each long enough for the ranked search. A
-// spelling below that floor is its own question, as every name of a batch was before. Each list is one
-// question with one receipt row, so a list that crowds or fails takes no other list down with it. PURE.
+// A BATCH OF SPELLINGS GOES AS THE PLANNER'S LISTS where the register takes one: exact spellings up to
+// `exactOrWidth`, sound-alike ones up to `phoneticOrWidth` within the register's word budget (ruled 2026-10-09
+// for sound-alikes; the exact width is the one the plan's own spelling band already uses), each spelling long
+// enough for the ranked search. A spelling below that floor is its own question, and so is every name of a batch
+// with an owner or on any other predicate, as before. Each list is one question with one receipt row, so a list
+// that crowds or fails takes no other list down with it. PURE.
 function splitBatch(p, names, capabilities) {
   const { terms: _batch, ...rest } = p;
   const single = (t) => ({ ...rest, term: t });
-  const width = Math.floor(Number(capabilities?.phoneticOrWidth));
-  if (String(p?.predicate ?? "") !== "phonetic" || !(width >= 2)) return names.map(single);
+  const predicate = String(p?.predicate ?? "");
+  const width = predicate === "exact" ? planExactOrWidth(capabilities) : predicate === "phonetic" ? planPhoneticOrWidth(capabilities) : 1;
+  if (!(width >= 2) || (typeof p?.owner === "string" && p.owner.trim())) return names.map(single);
   const floor = Number(capabilities?.rankedMinLength) || 0;
-  const budget = Number(capabilities?.listWordBudget) || Infinity;
+  const budget = predicate === "phonetic" ? (Number(capabilities?.listWordBudget) || Infinity) : Infinity;
   const words = (t) => t.split(/\s+/).filter(Boolean).length;
   const folded = (t) => [...t.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/\s+/g, "")].length;
   const out = [];
@@ -427,9 +438,29 @@ export async function proposeSupplemental(params, tctx, deps) {
   if (!offered.length)
     return { type: "text", text: JSON.stringify({ minted: [], reused: [], rejected: [], excluded_house_element: excludedHouse, executed: false }, null, 2) };
   const existingQids = new Set(supp.entries.map((e) => e.qid));
-  const { minted, reused, rejected, enriched, narrowed } = mintSupplementalEntries(axis, offered,
+  let { minted, reused, rejected, enriched, narrowed } = mintSupplementalEntries(axis, offered,
     { existingQids, capabilities: deps.capabilities ?? null, priorityClasses: planClasses });
 
+  // ── ONE ANSWER PER QUESTION PER RUN (held-answers.mjs) ───────────────────────────────────────────
+  // A question another worker or pass has already answered gets that answer, and one the run has decided not to ask
+  // gets that decision: it is not minted, not run, and costs no call. A failed answer is no answer, so it is asked again.
+  const held = [];
+  try {
+    const runDir = dirname(dirname(outPath));
+    const index = heldAnswers(runDir, { planRegions, withheld: readWithheldFamilies(runDir) });
+    if (index.size) {
+      const fresh = [];
+      for (const e of minted) {
+        const h = index.get(questionKey(e, planRegions));
+        if (!h || h.qid === e.qid) { fresh.push(e); continue; }
+        held.push({ question: compactProposal(e), decision: h.decision, ...(h.qid ? { answered_by: h.qid, axis: h.axis } : {}),
+          ...(h.block ? { state: h.block.state ?? null, total_hits: h.block.total_hits ?? null,
+            count: h.block.count ?? (Array.isArray(h.block.records) ? h.block.records.length : null), records_preview: preview(h.block.records) } : {}) });
+      }
+      minted = fresh;
+    }
+  } catch { /* the held index is an economy: without it every question is asked as before */ }
+
   // Field-level romanisation enrichment of a REUSED qid (2026-07-30 review round): the natural retry —
   // a bare non-Latin proposal deferred at the wire, the model re-proposes it WITH the romanisation —
   // reuses the same deterministic qid, and without this the stored bare entry re-executed verbatim and
@@ -486,7 +517,15 @@ export async function proposeSupplemental(params, tctx, deps) {
     renameSync(`${suppPath}.tmp`, suppPath);
   }
 
-  const qids = [...minted.map((e) => e.qid), ...reused];
+  // A question this worker re-proposes that already holds an answer is not run again: the answer stands. One with no
+  // answer, a failed one, or one this call enriched or gave its markets runs as before.
+  let reusedHeld = [];
+  try {
+    const own = new Map();
+    for (const b of JSON.parse(readFileSync(outPath, "utf8"))) if (b?.qid) own.set(String(b.qid), b);
+    reusedHeld = reused.filter((q) => { const b = own.get(String(q)); return b && b.error !== true && !enrichedQids.includes(q) && !staleOnDisk; });
+  } catch { reusedHeld = []; }
+  const qids = [...minted.map((e) => e.qid), ...reused.filter((q) => !reusedHeld.includes(q))];
   let summary = null;
   if (qids.length) {
     const r = await executePlan({ plan_path: suppPath, axis, output_path: outPath, qids }, tctx);
@@ -497,13 +536,36 @@ export async function proposeSupplemental(params, tctx, deps) {
     try { summary = JSON.parse(text); } catch { summary = { raw: text.slice(0, 300) }; }
   }
 
+  // A FOLLOW-UP THE RUN'S SAFETY NET DID NOT SEND never ran and has no answer (follow-up-searches.mjs). One minted by this
+  // call leaves the plan the fold reads, so it is never taken for a planned question that went missing, and is
+  // kept as a question not asked: a rejected[] row, which the ask ledger keeps open. One that ran before keeps its
+  // place and its answer.
+  const outstanding = Array.isArray(summary?.outstanding) ? summary.outstanding.map(String) : [];
+  const mintedHere = new Map(minted.map((e) => [e.qid, e]));
+  const refusedHere = outstanding.filter((q) => mintedHere.has(q));
+  if (refusedHere.length) {
+    let cur = supp;
+    try { cur = JSON.parse(readFileSync(suppPath, "utf8")); } catch { /* the in-memory plan is what was written */ }
+    const gone = new Set(refusedHere);
+    cur = withRejected({ ...cur, entries: (Array.isArray(cur?.entries) ? cur.entries : []).filter((e) => !gone.has(e?.qid)) },
+      // The markets and goods ride on the row: the ask ledger keeps one ask per (issue, proposal), and the compact
+      // proposal alone would fold the same question refused for several markets into one ask naming none.
+      refusedHere.map((q) => { const e = mintedHere.get(q); return { issue: OUTSTANDING_REASON, proposal: { ...compactProposal(e),
+        ...(Array.isArray(e?.regions) && e.regions.length ? { regions: e.regions.map(String).slice(0, 200) } : {}),
+        ...(Array.isArray(e?.goods_text) && e.goods_text.length ? { goods_text: e.goods_text.map((g) => String(g).slice(0, 80)).slice(0, 20) } : {}) } }; }),
+      { ts: new Date().toISOString(), origin: "propose-tool" });
+    mkdirSync(dirname(suppPath), { recursive: true });
+    writeFileSync(`${suppPath}.tmp`, JSON.stringify(cur, null, 2) + "\n");
+    renameSync(`${suppPath}.tmp`, suppPath);
+  }
+
   // read the results BACK FROM THE BAND — the reasoning payload is never model-transcribed
   const results = {};
   try {
     const band = JSON.parse(readFileSync(outPath, "utf8"));
     const blocks = Array.isArray(band) ? band : [];
     for (const b of blocks) {
-      if (!b || typeof b !== "object" || !b.qid || !qids.includes(b.qid)) continue;
+      if (!b || typeof b !== "object" || !b.qid || !(qids.includes(b.qid) || reusedHeld.includes(b.qid))) continue;
       results[b.qid] = {
         state: b.state ?? null,
         total_hits: b.total_hits ?? null,
@@ -517,5 +579,5 @@ export async function proposeSupplemental(params, tctx, deps) {
     }
   } catch { /* band unreadable — the executor summary still crosses */ }
 
-  return { type: "text", text: JSON.stringify({ minted: minted.map((e) => e.qid), reused, ...(enrichedQids.length ? { enriched: enrichedQids } : {}), ...(conflicts.length ? { conflict: conflicts } : {}), rejected, ...(excludedHouse.length ? { excluded_house_element: excludedHouse } : {}), ...(narrowed.length ? { narrowed } : {}), executed: qids.length > 0, summary, results }, null, 2) };
+  return { type: "text", text: JSON.stringify({ minted: minted.map((e) => e.qid).filter((q) => !refusedHere.includes(q)), reused, ...(enrichedQids.length ? { enriched: enrichedQids } : {}), ...(conflicts.length ? { conflict: conflicts } : {}), rejected, ...(outstanding.length ? { outstanding } : {}), ...(held.length ? { held } : {}), ...(outstanding.length || held.some((h) => h.decision === "outstanding") ? { outstanding_note: OUTSTANDING_NOTE } : {}), ...(reusedHeld.length ? { held_answer_kept: reusedHeld } : {}), ...(excludedHouse.length ? { excluded_house_element: excludedHouse } : {}), ...(narrowed.length ? { narrowed } : {}), executed: qids.length > 0, summary, results }, null, 2) };
 }

package/driver/package.json

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