clearotron 0.4.0 → 0.4.1-beta.0

package/driver/verify.mjs

@@ -16,7 +16,7 @@ import { matterFrameWasRecorded, frameRatifiedForms } from "./matter-frame-recor
 import { findConnotationViolations, parsePrRiskResults, prRiskPopulation,
   CONNOTATION_UNMATCHED_MARK, CONNOTATION_NO_RESEMBLANCE_MARK, MEANING_ANGLES_RE,
   parseDispositionForm, CONNOTATION_UNRULED_REASONS, queryKey } from "./connotation-search.mjs";
-import { formSidecarName, formSidecarPath } from "./disposition-union.mjs"; import { coverageStatusAsData } from "./common-law-coverage-status.mjs";
+import { formSidecarName, formSidecarPath } from "./disposition-union.mjs";
 // B — the transport's own four failure states. The audit reads the run's records; this file locates them.
 import { auditDispositionCalls, CALL_FAILURE_REASONS } from "./disposition-call-audit.mjs";
 import { callRecordPaths } from "./disposition-tool.mjs";
@@ -37,7 +37,7 @@ import { registerPlanCallKilled } from "./tool-calls.mjs";   // — did the dict
 import { parseFindingsJson, parseFindingsJsonLenient, CLIENT_TIER_BY_COMPOSITE, isUnconditionalProceed, joinFindingToBlock, parseBlockOrd } from "./findings-model.mjs";
 import { parsePlacementsJson } from "./placement-model.mjs"; import { placementFormSidecarName, parsePlacementForm, placementRenderAccount } from "./placement-form.mjs";
 import { parseCaseLawLedger, findCaseLawLedgerViolations, caseLawLedgerFail } from "./case-law-ledger.mjs";
-import { parseFrameworkManifest, aboveLowestBand, normalizeBand } from "./framework.mjs"; import { readFrozenMethod, FROZEN_METHOD_FILE } from "./framework-method.mjs";
+import { parseFrameworkManifest, materialBand, normalizeBand } from "./framework.mjs"; import { readFrozenMethod, FROZEN_METHOD_FILE } from "./framework-method.mjs";
 import { parseNamedBand, findCollapsedBands } from "./named-band.mjs";
 import { parseBlindFrameModel } from "./blind-frame-model.mjs";
 import { parseFrameDiff } from "./frame-diff-model.mjs";
@@ -681,7 +681,7 @@ function commonLawStructural(c, p = null) {
     needsSection(c, "coverage-ledger", [/coverage[\s-]ledger/i], "coverage-ledger"),
     needsSection(c, "audit-trail", [/audit[\s-]trail/i], "audit-trail"),
     needs(c, [/\|/], "platform matrix"),
-    coverageStatusAsData(p) || hasCoverageLedgerRow(c) ? ok() : fail("no_coverage_status_row"),   // the recorded status first, the word as fallback: coverageStatusAsData() in common-law-coverage-status.mjs
+    // no status check here (ruling 2026-10-01): a ledger with no status word and no record passes, and code records what it states — recordStatusesFromFindings() in common-law-coverage-status.mjs
   );
 }
 
@@ -1203,9 +1203,9 @@ function checkFindingsSibling(p, c) {
   const v4 = (parsed.schemaVersion ?? 1) >= 4;
   if (v4 && !fw.manifest) return fail("framework_manifest_missing_for_v4: schema_version 4 findings need the frozen _driver/framework.json to judge band words");
   const v3 = (parsed.schemaVersion ?? 1) >= 3;   // gates key on schema_version — v2/archived runs and replay never flip
-  // "material finding" — the line the receipt gates key on: composite>=3 on the legacy scale; on v4,
-  // banded ABOVE the framework's lowest band (judgment-free re-expression of the same line).
-  const material = (f) => v4 ? (f.band != null && aboveLowestBand(fw.manifest, f.band)) : f.composite >= 3;
+  // "material finding" — the line the receipt gates key on: composite>=3 on the legacy scale; on v4, banded on
+  // a rung whose own tone is medium risk or higher (materialBand — by tone, never by position on the ladder).
+  const material = (f) => v4 ? (f.band != null && materialBand(fw.manifest, f.band)) : f.composite >= 3;
   for (const f of parsed.findings) {
     if (material(f) && f.use_check != null && !String(f.use_check.source ?? "").trim())
       return fail(`finding_use_check_source_missing:${f.ordinal}`);

package/mcp-server/CHANGELOG.md

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

package/mcp-server/lib/evidence.mjs

@@ -294,7 +294,7 @@ const MATCH_SHAPES = [
 // `*` wildcard, and the term extractor must see the word, not the markup.
 const deMarkup = (s) => String(s ?? "").replace(/\*\*|__/g, "");
 
-// Record COUNTS ride along in parentheses — `PARADISE (424)`, `パラダイス (34) / 파라다이스 (20)`. They are
+// Record COUNTS ride along in parentheses — `HAVEN (424)`, `ヘイヴン (34) / 헤이븐 (20)`. They are
 // process exhaust rather than the query, and dropping them first is what lets the rest of the string be
 // recognised as the bare term it is.
 const deCount = (s) => String(s ?? "").replace(/\s*\(\s*~?\s*[\d,]+\s*\)/g, "");
@@ -302,26 +302,26 @@ const deCount = (s) => String(s ?? "").replace(/\s*\(\s*~?\s*[\d,]+\s*\)/g, "");
 // A searched term is recognised three ways, in order, and NOT recognised otherwise:
 //   1. explicitly quoted — `exact "Drivers Haven" (default)`
 //   2. the whole string, when it carries no query scaffolding at all. This is how the common-law sweep
-//      writes them and it is the bulk of the corpus: `레이서스 파라다이스`, `赛车天堂`, `RACERZ`,
-//      `PARADISE WORLD`. Those scripts are caseless, so a capitals rule cannot see them at all.
+//      writes them and it is the bulk of the corpus: `드라이버스 헤이븐`, `车手港湾`, `DRIVERZ`,
+//      `HAVEN WORLD`. Those scripts are caseless, so a capitals rule cannot see them at all.
 //      "No scaffolding" is checked positively: no match-shape keyword, no residual parenthetical, and
 //      none of the structural punctuation the audit uses for anything OTHER than a query (a record path,
 //      a bracketed class list, an em-dash clause, a key: value tail).
-//   3. an ALL-CAPS token — `exact PARADISE`, `*PARADISE / fuzzy`. Two-letter tokens (ZH, JP, DE) are
+//   3. an ALL-CAPS token — `exact HAVEN`, `*HAVEN / fuzzy`. Two-letter tokens (ZH, JP, DE) are
 //      language/jurisdiction codes, not marks, and the register offices above are offices, not marks.
 const SCAFFOLD = /[[\]`:—]|\/mark\//;
 
 // "Does this read as a NAME?" — the property that separates a searched mark from a description of a
 // search. Every alphabetic token must start upper-case or be in a caseless script (CJK, Hangul, Kana,
-// Arabic); a token that is entirely lower-case Latin is prose. So `Racer's Paradise`, `PARADISE WORLD`,
-// `Вензи` and `레이서스 파라다이스` qualify and `national register`, `formative phrases` and
+// Arabic); a token that is entirely lower-case Latin is prose. So `Driver's Haven`, `HAVEN WORLD`,
+// `Вензи` and `드라이버스 헤이븐` qualify and `national register`, `formative phrases` and
 // `one-swap lead-noun neighbours` do not. A property, not a list of banned words — a description nobody
 // anticipated still fails it.
 function looksLikeName(s) {
   const tokens = String(s).split(/\s+/).filter((t) => /\p{L}/u.test(t));
   if (!tokens.length || tokens.length > 5) return false;
   // A lone two-letter capital is a language or jurisdiction code (ZH, DE, JP), never a mark. Caseless
-  // scripts are exempt from the length floor — 天堂 is a whole word in two characters.
+  // scripts are exempt from the length floor — 港湾 is a whole word in two characters.
   const cased = tokens.filter((t) => /\p{Lu}|\p{Ll}/u.test(t));
   if (cased.length && cased.every((t) => t.replace(/[^\p{L}]/gu, "").length <= 2)) return false;
   return tokens.every((t) => !/^\p{Ll}/u.test(t.replace(/^[^\p{L}\p{N}]+/u, "")));
@@ -361,7 +361,7 @@ function extractTerm(raw) {
 const asClasses = (nums) => [...new Set(nums.map(Number).filter((n) => Number.isInteger(n) && n >= 1 && n <= 45))];
 
 // In a SEARCH TERM, classes are read only where they are LABELLED ("cl 9/28/41/42", "cl.25", "class 35") —
-// never from a bare parenthesised number, which in this corpus is a record COUNT ("PARADISE (424)").
+// never from a bare parenthesised number, which in this corpus is a record COUNT ("HAVEN (424)").
 function extractClasses(s) {
   const m = String(s ?? "").match(/\bcl(?:ass(?:es)?)?\.?\s*([\d]{1,2}(?:\s*[/,]\s*\d{1,2})*)/i);
   return m ? asClasses(m[1].split(/[/,]/)) : [];

package/mcp-server/lib/knockout.mjs

@@ -388,7 +388,7 @@ export function traceKnockout(run, target, events = []) {
     kind: "verdict",
     verdict: doc?.batch?.overall ?? runVerdictFromEvents(events) ?? null,
     marks: marksOf(doc).map((m) => ({ mark: m.name, band: m.rating ?? null, basis: m.basis ?? null })),
-    note: "A Knockout verdict is the batch's worst band across its marks; each mark's own band and the "
+    note: "A Knockout verdict is the highest rating across the batch's marks; each mark's own rating and the "
       + "one-sentence ground for it are listed here.",
   });
 

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-artifacts-mcp",
-  "version": "0.4.0",
+  "version": "0.4.1-beta.0",
   "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.",
@@ -13,7 +13,7 @@
     "test:full": "npm run test"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.31.0",
     "jose": "^6.2.3"
   },
   "engines": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clearotron",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.4.1-beta.0",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",
@@ -73,7 +73,7 @@
     "globals": "^17.11.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.31.0",
     "buffers": "file:vendor/buffers",
     "exceljs": "^4.4.0",
     "jose": "^6.2.3",

package/portal-ui/package.json

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

package/providers/_shared/count.mjs

@@ -112,6 +112,9 @@ export function makeCountProbe(deps) {
       return { ok: false, total: null, probe: "cheap",
         reason: "the search response carried no usable total_hits, so nothing was counted — the number is UNKNOWN, which is not the same as none" };
     }
-    return { ok: true, total: parsed.total_hits, probe: "cheap", reason: null };
+    // What the total counts rides with it when the register said (a provider's `total_counts`, see
+    // enumerate.mjs): a per-class or per-spelling count keeps the register's number and says so.
+    return { ok: true, total: parsed.total_hits, probe: "cheap", reason: null,
+      ...(typeof parsed.total_counts === "string" ? { total_counts: parsed.total_counts } : {}) };
   };
 }

package/providers/_shared/enumerate.mjs

@@ -220,6 +220,13 @@ export function makeEnumerate(deps) {
     // against the tuned ceiling below and can only ever narrow it — `CLEAROTRON_ENUMERATE_CEILING` cannot
     // raise a band past a window the vendor answers with an HTTP 400.
     ceilingFor = null,
+    // ── HOW MANY NAMES ONE REQUEST CARRIES, WHEN THAT IS A PROPERTY OF THE QUERY ──────────────────
+    //
+    // `namesChunkDefault` models a provider with one width for every names band. A register can take a
+    // list for one kind of question and not another — signa takes up to 100 exact spellings as one ranked
+    // list, and one term per request for everything else. `(params) => number|null`; `null` means the
+    // shape declares nothing and the default (or `CLEAROTRON_ENUMERATE_NAMES_CHUNK`) stands.
+    namesChunkFor = null,
   } = deps;
 
   // ── the I/O seam: a network REJECTION degrades like a 503, it does not abort the stage ────────────
@@ -288,19 +295,17 @@ export function makeEnumerate(deps) {
   // asks a register "how many", so the two can never drift. `null` on any failure is preserved
   // exactly: a term whose probe failed is dispositioned `error`, never `verified-zero`.
   const countHits = makeCountProbe({ search, count, capabilities: { countProbe }, cheapCountParams });
-  const probeTermCount = async (auth, params, term, tctx) => {
-    const c = await countHits(auth, { ...params, [namesKey]: [term] }, tctx);
-    return c.ok ? c.total : null;
-  };
 
   async function countFirstRescue(auth, params, names, ceiling, stackTotal, tctx, incomplete) {
     const term_counts = {};
     for (const t of names) {
-      const n = await probeTermCount(auth, params, t, tctx);
+      const probe = await countHits(auth, { ...params, [namesKey]: [t] }, tctx);
+      const n = probe.ok ? probe.total : null;
+      const said = countsOf(probe);   // what this spelling's own count counts, when the register said
       if (n == null) { term_counts[t] = { total_hits: null, disposition: "error" }; continue; }
-      if (n === 0) term_counts[t] = { total_hits: 0, disposition: "verified-zero" };
-      else if (n > ceiling) term_counts[t] = { total_hits: n, disposition: "crowd" };
-      else term_counts[t] = { total_hits: n, disposition: "unenumerated" };
+      if (n === 0) term_counts[t] = { total_hits: 0, disposition: "verified-zero", ...said };
+      else if (n > ceiling) term_counts[t] = { total_hits: n, disposition: "crowd", ...said };
+      else term_counts[t] = { total_hits: n, disposition: "unenumerated", ...said };
     }
     const records = [];
     const tally = { "verified-zero": 0, enumerated: 0, crowd: 0, unenumerated: 0, error: 0 };
@@ -344,20 +349,21 @@ export function makeEnumerate(deps) {
     for (const c of classes) {
       const probe = await countHits(auth, { ...params, nice_classes: [c] }, tctx);
       const n = probe.ok ? probe.total : null;
+      const said = countsOf(probe);   // what this class's own count counts, when the register said (ruling 712)
       if (n == null) { class_counts[c] = { total_hits: null, disposition: "error" }; continue; }
-      if (n === 0) class_counts[c] = { total_hits: 0, disposition: "verified-zero" };
-      else if (n > ceiling) class_counts[c] = { total_hits: n, disposition: "crowd" };
-      else tractable.push({ c, n });
+      if (n === 0) class_counts[c] = { total_hits: 0, disposition: "verified-zero", ...said };
+      else if (n > ceiling) class_counts[c] = { total_hits: n, disposition: "crowd", ...said };
+      else tractable.push({ c, n, said });
     }
     tractable.sort((a, b) => a.n - b.n); // cheapest first — maximizes fully-enumerated legs under the budget
     const merged = new Map();
-    for (const { c, n } of tractable) {
-      if (merged.size + n > ceiling) { class_counts[c] = { total_hits: n, disposition: "unenumerated" }; continue; }
+    for (const { c, n, said } of tractable) {
+      if (merged.size + n > ceiling) { class_counts[c] = { total_hits: n, disposition: "unenumerated", ...said }; continue; }
       const r = await enumerate(auth, { ...params, nice_classes: [c] }, tctx);
       const parsed = isToolError(r) ? null : parseToolText(r);
-      if (!parsed) { class_counts[c] = { total_hits: n, disposition: "error" }; continue; }
+      if (!parsed) { class_counts[c] = { total_hits: n, disposition: "error", ...said }; continue; }
       if (parsed.state === "enumerated") {
-        class_counts[c] = { total_hits: n, disposition: "enumerated" };
+        class_counts[c] = { total_hits: n, disposition: "enumerated", ...said };
         for (const rec of (parsed.records ?? [])) {
           const k = recordKeyOf(rec);
           if (!merged.has(k)) merged.set(k, rec);
@@ -365,7 +371,7 @@ export function makeEnumerate(deps) {
       } else {
         // drifted past the probe count (provider re-count) or hit the provider window — honest per-leg state
         const m = parsed.total_hits ?? n;
-        class_counts[c] = { total_hits: m, disposition: m > ceiling ? "crowd" : "error" };
+        class_counts[c] = { total_hits: m, disposition: m > ceiling ? "crowd" : "error", ...(Number.isFinite(parsed.total_hits) ? countsOf(parsed) : said) };
       }
     }
     const records = [...merged.values()];
@@ -399,7 +405,7 @@ export function makeEnumerate(deps) {
   // half's own reason, as a names window does: a clean never ships over a part that did not run.
   // `region_split` rides the answer, naming the timeout that started it and the size of every part that
   // answered, so a reader can see the question was asked in pieces and where.
-  async function regionHalves(auth, params, tctx, { ceiling, incomplete, cause }) {
+  async function regionHalves(auth, params, tctx, { ceiling, incomplete, cause, hear = () => {} }) {
     const regions = params.regions;
     const mid = Math.ceil(regions.length / 2);
     const halves = [regions.slice(0, mid), regions.slice(mid)];
@@ -435,9 +441,10 @@ export function makeEnumerate(deps) {
       // A half that timed out while its sibling answered is the one place fewer regions may help: it is
       // halved in turn, under the same rule.
       const r = timedOut({ r: first })
-        ? await regionHalves(auth, { ...params, regions: half }, tctx, { ceiling, incomplete, cause: parseToolText(first)?.reason ?? cause })
+        ? await regionHalves(auth, { ...params, regions: half }, tctx, { ceiling, incomplete, cause: parseToolText(first)?.reason ?? cause, hear })
         : first;
       const parsed = isToolError(r) ? null : parseToolText(r);
+      hear(parsed);
       const which = `the ${half.length}-region half ${half[0]}${half.length > 1 ? `…${half[half.length - 1]}` : ""}`;
       // A stall from a deeper split keeps its own reason, stall first, so the executor reads it however
       // deep the split went and however short the reason is later cut.
@@ -464,8 +471,22 @@ export function makeEnumerate(deps) {
       ...(screenLift ? { screen_lift: screenLift } : {}), region_split: { cause, parts } }, null, 2) };
   }
 
-  async function enumerate(auth, params, tctx, { split = true } = {}) {
+  // ── WHAT THE TOTAL COUNTS, STATED ONCE FOR THE WHOLE ANSWER ────────────────────────────────────────
+  //
+  // A register can say that a total counts records, one per country a mark covers, rather than marks
+  // (`total_counts` on a provider's parsed answer). The answer to the question states it, whichever of the
+  // exits below produced it: the page loop, the name windows, the region halves and the rescues each tell
+  // the question what they heard, and it is stamped here, on the one way out. Recorded only: the ceiling
+  // still reads the register's own number (ruled 2026-10-02). An answer with no `total_counts` is one whose
+  // register said nothing about it, never a count of marks.
+  async function enumerate(auth, params, tctx, opts = {}) {
+    const said = { totalCounts: null };
+    return stampTotalCounts(await enumerateQuestion(auth, params, tctx, opts, said), said.totalCounts);
+  }
+
+  async function enumerateQuestion(auth, params, tctx, { split = true } = {}, said = { totalCounts: null }) {
     if (!hasAnyElement(params)) return { type: "text", text: missingElementError };
+    const hear = (p) => { if (typeof p?.total_counts === "string") said.totalCounts = p.total_counts; };
 
     // The tuned ceiling, then narrowed by any window the QUERY SHAPE imposes. Min, never max:
     // a shape window is a vendor limit, and a band that pages past it does not return more records, it
@@ -499,7 +520,9 @@ export function makeEnumerate(deps) {
     // descriptor total — `count` is the deduped truth); the resource ceiling applies to the RUNNING total
     // so a crowd still returns an incomplete descriptor. ANY chunk error/incomplete makes the WHOLE slice
     // incomplete — a clean can never ship over a partially-executed slice.
-    const namesChunk = envInt("CLEAROTRON_ENUMERATE_NAMES_CHUNK", namesChunkDefault);
+    const shapeChunk = typeof namesChunkFor === "function" ? namesChunkFor(params) : null;
+    const namesChunk = Number.isFinite(shapeChunk) && shapeChunk >= 1
+      ? Math.floor(shapeChunk) : envInt("CLEAROTRON_ENUMERATE_NAMES_CHUNK", namesChunkDefault);
     const allNames = Array.isArray(params[namesKey]) ? params[namesKey].filter(Boolean) : null;
     if (allNames && allNames.length > namesChunk) {
       const merged = new Map();
@@ -518,6 +541,7 @@ export function makeEnumerate(deps) {
         const part = allNames.slice(i * namesChunk, (i + 1) * namesChunk);
         const r = await enumerate(auth, { ...params, [namesKey]: part }, tctx);
         const parsed = parseToolText(r);
+        hear(parsed);
         if (isToolError(r) || !parsed) {
           return incomplete(totalSum, merged.size, [...merged.values()],
             `chunk ${i + 1}/${chunks} (${part.length} names) failed: ${String(r?.text ?? "unparseable").slice(0, 140)}`,
@@ -599,10 +623,11 @@ export function makeEnumerate(deps) {
             + `Provider's own words: ${clipProviderText(c?.reason ?? "", COUNT_PROBE_BUDGET)}`,
             { crowd_basis: "provider-refused-count", count_unavailable: true });
         }
-        if (splittable && isGatewayTimeout(c?.reason)) return regionHalves(auth, params, tctx, { ceiling, incomplete, cause: String(c.reason) });
+        if (splittable && isGatewayTimeout(c?.reason)) return regionHalves(auth, params, tctx, { ceiling, incomplete, cause: String(c.reason), hear });
         return incomplete(0, 0, [],
           `provider error on the count probe before enumeration: ${String(c?.reason ?? "count unavailable")}`, timeoutMark(c?.reason));
       }
+      hear(c);
       total = Number.isFinite(c.total) ? c.total : 0;
       probeTotal = total;
       if (total > ceiling) {
@@ -625,11 +650,12 @@ export function makeEnumerate(deps) {
     for (let page = 0; ; page += 1) {
       const r = await search(auth, { ...params, ...pageParams(page, pageSize, prevParsed) }, tctx);
       if (isToolError(r)) {
-        if (splittable && isGatewayTimeout(r.text)) return regionHalves(auth, params, tctx, { ceiling, incomplete, cause: String(r.text) });
+        if (splittable && isGatewayTimeout(r.text)) return regionHalves(auth, params, tctx, { ceiling, incomplete, cause: String(r.text), hear });
         return incomplete(total, results.length, results, `provider error during enumeration (page ${page}): ${String(r.text ?? "")}`, timeoutMark(r.text));
       }
       const parsed = parseToolText(r);
       if (!parsed) return incomplete(total, results.length, results, `unparseable search response during enumeration (page ${page})`);
+      hear(parsed);
       // ── the number the completeness claim rests on must BE a number ────────────────────────────────
       // On the "cheap" seam the page response IS the count — the ceiling is tested off `total_hits` and
       // nothing else. A response that parsed but carries no usable total therefore cannot support a
@@ -811,3 +837,16 @@ export function makeEnumerate(deps) {
 
   return { enumerate, countFirstRescue, classSplitRescue };
 }
+
+/** `{ total_counts }` from a probe or a parsed answer that carries it, else nothing to spread. PURE. */
+function countsOf(p) {
+  return typeof p?.total_counts === "string" ? { total_counts: p.total_counts } : {};
+}
+
+/** The answer with what its total counts stated on it; an error, or nothing heard, passes unchanged. */
+function stampTotalCounts(r, totalCounts) {
+  if (!totalCounts || isToolError(r)) return r;
+  const parsed = parseToolText(r);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return r;
+  return { ...r, text: JSON.stringify({ ...parsed, total_counts: totalCounts }, null, 2) };
+}

package/providers/_shared/execute-plan.mjs

@@ -509,6 +509,8 @@ export function makeExecutePlan(deps) {
           // the resolution the sweep actually ran on, verbatim — a reader must be able to see WHICH
           // applicant styling was asked for, on a verified zero as much as on an unverified one.
           ...(parsed?.owner_resolution ? { owner_resolution: parsed.owner_resolution } : {}),
+          // what the counted total counts, when the register said (enumerate.mjs, "what the total counts")
+          ...(counted && typeof parsed?.total_counts === "string" ? { total_counts: parsed.total_counts } : {}),
           reason: ownerUnverified ? unresolvedOwnerCountReason(e.term ?? (e.terms ?? [])[0], coveredBy)
             : parsed ? descriptorReason
             : `provider error on the count probe (after one in-tool retry): ${clipProviderText(r?.text ?? "", 100)}` });

package/providers/corsearch/src/capabilities.js

@@ -38,7 +38,7 @@ export const CAPABILITIES = Object.freeze({
   countStatusFilter: "none",
   // HTTP-414 URI guard: the whole query is a GET query string, so ~80 backtick-quoted names (≈2–4KB
   // encoded) is the safe OR-stack. This MIRRORS the executor's ENUMERATE_NAMES_CHUNK_DEFAULT — the
-  // planner must never dictate an OR-stack the executor would have to chunk-rescue (Wilderness 414).
+  // planner must never dictate an OR-stack the executor would have to chunk-rescue (Open Country 414).
   maxOrWidth: 80,
   // `nice-class` clauses ride the same query string (implicit OR within the field) — one call, no fan-out.
   classFilter: "native",

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

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

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

@@ -1,13 +1,13 @@
 {
   "name": "trademark-oauth-mcp-bridge",
-  "version": "0.4.0",
+  "version": "0.4.1-beta.0",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "OAuth 2.1 MCP stdio bridge used by the engine's case-law gather stage (courtlistener / legaldatahunter).",
   "type": "module",
   "main": "bridge.mjs",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@modelcontextprotocol/sdk": "^1.31.0"
   },
   "engines": { "node": ">=22.13.0" }
 }

package/providers/signa/src/capabilities.js

@@ -120,9 +120,24 @@ export const CAPABILITIES = Object.freeze({
   // NOTE the key. `filters.status` does not exist and the API rejects unknown filter keys outright
   // (`HTTP 400 Unrecognized key: status`) — which is what core.js was sending until this issue.
   countStatusFilter: "native",
-  // The request carries ONE `query` string. There is no OR-stack surface at all — an N-name band is N
-  // calls, so the planner must emit one term per entry.
+  // The request carries ONE `query` string for every predicate but one, so the general OR width stays 1:
+  // a phonetic, wildcard or owner band is one call per term, and anything that reads this width as
+  // "no OR at all" (the supplemental batch's one-question-per-name split) keeps reading it that way.
   maxOrWidth: 1,
+  // ── THE ONE PREDICATE THAT TAKES A LIST: exact spellings, up to 100 per request ─────────────────
+  //
+  // A list in `q` is a ranked search over every spelling through the channels the request names, and
+  // each record says which spellings found it (`match.terms`). The register takes up to 100 spellings
+  // when the channels are only `identical` and `lookalike` — which is exactly what an exact question
+  // sends — and 10 otherwise. Measured live against one search per spelling, by record id and paged to
+  // exhaustion: the same records on the exact band at 32 and at 100 spellings, look-alike-only records
+  // included, with every record's `match.terms` naming exactly the spellings that found it alone. The
+  // figures are on the tracker. The one documented difference — a list skips the word-by-word fuzzy
+  // retry — belongs to a channel the exact question does not send.
+  //
+  // So the planner stacks an exact spelling band at this width, and the kernel sends each stack as one
+  // request (`namesChunkFor` in core.js); every other predicate stays at `maxOrWidth`.
+  exactOrWidth: 100,
   // filters.nice_classes[] is a top-level OR filter — one call, no fan-out.
   classFilter: "native",
   // ── THE GOODS-AND-SERVICES TEXT FILTER ──────────────────────────────────────────────────────────