clearotron 0.3.3 → 0.4.0-beta.1

package/driver/driver.config.mjs

@@ -668,13 +668,12 @@ export const config = {
 // Owner's ruling, 2026-09-23: record the tier. What a run asked for is a tier, what it was served is
 // recorded separately and already is, and the report names the model that ran — none of that moves.
 //
-// WHAT IT COSTS, RULED ON AND ACCEPTED RATHER THAN DISCOVERED LATER. Per-model totals are keyed on what
-// was ASKED for, and the direct-API lanes must name a version because they call the API rather than the
-// program — the API takes model ids, not tier words. So one model reached by both routes now lands in
-// two buckets: `anthropic/claude-haiku` from a stage, `anthropic/claude-haiku-4-5` from those lanes.
-// That is a real split in a per-model total and it was accepted with the ruling: the two are genuinely
-// different requests, and keying the totals on what actually SERVED each turn is the change that would
-// fix it properly, which is larger than this and not what was ruled.
+// WHAT IT COSTS, RULED ON AND ACCEPTED RATHER THAN DISCOVERED LATER. A stage's rows are keyed on the
+// tier it asked for, and a native-language lane's rows on the model that served them (`modelKey` in
+// tokens.mjs). So one model reached both ways lands in two buckets: `anthropic/claude-haiku` from a
+// stage, `anthropic/claude-haiku-4-5` from a native-language lane. That is a real split in a per-model
+// total and it was accepted with the ruling; keying every row on what served it is the change that
+// would close it, which is larger than this and not what was ruled.
 export const MODELS = {
   haiku: "anthropic/claude-haiku",
   sonnet: "anthropic/claude-sonnet",
@@ -693,8 +692,7 @@ export const MODELS = {
 // alias → full id; a value that's already a full provider/model id (contains "/") passes through.
 //
 // A BARE Anthropic id (dated or not — "claude-haiku-4-5-20251001", "claude-opus-5") normalises to the
-// catalog form too. The direct-API lanes (jx completions/judge/nativeread, driver.config JX_PROVIDERS)
-// name their model that way because that is what the Messages API takes, so without this one model named
+// catalog form too. Without this, one model named
 // in two spellings — dated and undated — would key apart in a rollup. The date suffix is dropped;
 // anything that does not look like a bare claude id is returned untouched, so a genuinely unknown model
 // still keys as-is rather than being guessed at.
@@ -1320,7 +1318,15 @@ export const PROVIDERS = {
         // The office's own numbers come off the full record Signa returns on search, through the
         // provider's own normaliser, so publish can address the office's page for each filing
         // (publish/office-record-links.mjs) instead of showing the handle.
-        return { ok: true, records: (Array.isArray(p.results) ? p.results : []).map((row) => {
+        //
+        // THE TOTAL RIDES THE SAME ANSWER and is carried, not dropped: `include_total` puts the register's
+        // own count for this exact question on every search, so the listing of a term already holds the
+        // figure the count lane would ask for separately. An approximation stays one: no number in
+        // `total`, the floor beside it — the count lane's rule, unchanged.
+        return { ok: true,
+          total: Number.isFinite(p.total_hits) ? p.total_hits : null,
+          ...(p.total_approximate === true ? { approximate: true, floor: Number.isFinite(p.total_floor) ? p.total_floor : null } : {}),
+          records: (Array.isArray(p.results) ? p.results : []).map((row) => {
           const rec = row?.raw && typeof row.raw === "object" ? core.normalizeRecord(row.raw, row.office || null) : null;
           return {
             record_id: row?.record_id ?? null,
@@ -2362,7 +2368,7 @@ export function preflightEngineBinary(env = process.env, { platform = process.pl
 
   if (r.relative) {
     throw new Error(`[preflight] ${where} is the RELATIVE path "${bin}", which cannot work: the engine is `
-      + "spawned with the RUN DIRECTORY as its cwd (#524), not the repo, so a relative command is looked "
+      + "spawned with the RUN DIRECTORY as its cwd, not the repo, so a relative command is looked "
       + `for inside the run. Give an absolute path — e.g. ${join(REPO_ROOT, bin)} — or a bare name on PATH.`);
   }
 

package/driver/e2e/README.md

@@ -37,7 +37,7 @@ other, which is the only proof available where no gold set exists.
 
 A knockout scenario graded against a similar-marks sheet scores a **structural zero**. Knockout answers
 one narrow question — how many register filings exist for the exact mark and its close variations in the
-named classes — and never retrieves similar marks, so a lawyer's list of TIKI PUNCH and TIKI TROPICS is
+named classes — and never retrieves similar marks, so a lawyer's list of WAVO PUNCH and WAVO TROPICS is
 unreachable by construction. R3 and R4 scored 0/8 and 0/9 on both free-tier and clarivate on the same
 day with the same engine, which measured the pairing rather than the engine.
 

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

@@ -121,6 +121,7 @@ serve({
         plan_path: { type: "string", description: "Absolute path to the frozen _driver/register-plan.json" },
         axis: { type: "string", description: "The register axis to execute (e.g. primary-sweep)" },
         output_path: { type: "string", description: "Absolute path of the named band to write (register-units/<axis>-band.json)" },
+        qids: { type: "array", items: { type: "string" }, description: "Optional: the qids of the plan entries to run. Only those run, and every other block in the band stays as it is. Leave it out only on the axis's first run: without it every entry on the axis runs again." },
       } },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       handler: guard((a) => doExecutePlan(API_KEY, BASE, a, tctx("execute_plan"))),
@@ -134,7 +135,7 @@ serve({
         proposals: { type: "array", minItems: 1, items: { type: "object", properties: {
           predicate: { type: "string", enum: ["exact", "default", "wildcard", "phonetic", "owner"] },
           term: { type: "string" }, terms: { type: "array", items: { type: "string" } },
-          romanization: { type: "string", description: "The Latin-script form of a NON-LATIN term — plain ASCII letters/digits, syllable-separated by single spaces, no tone marks or diacritics (华威豹 → \"HUA WEI BAO\", ティキスラッシュ → \"TIKI SURASSHU\"). MANDATORY beside a non-Latin term: without it this register cannot answer the characters and the slice defers. Single-term proposals only (never an OR-stack, never predicate:owner), and never on a term that is already Latin." },
+          romanization: { type: "string", description: "The Latin-script form of a NON-LATIN term — plain ASCII letters/digits, syllable-separated by single spaces, no tone marks or diacritics (华威豹 → \"HUA WEI BAO\", ワボスラッシュ → \"WABO SURASSHU\"). MANDATORY beside a non-Latin term: without it this register cannot answer the characters and the slice defers. Single-term proposals only (never an OR-stack, never predicate:owner), and never on a term that is already Latin." },
           owner: { type: "string", description: "OPTIONAL owner scope field on a MARK-TEXT proposal: the query is the owner×term intersection (the owner's filings within the term band). Not allowed on predicate:owner (there the owner name IS the term)." },
           nice_classes: { type: "array", items: {} },
           // The narrowing fields every register serves (proposal-fields.mjs); this register's two facts ride in.

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

@@ -104,6 +104,7 @@ serve({
         plan_path: { type: "string", description: "Absolute path to the frozen _driver/register-plan.json" },
         axis: { type: "string", description: "The register axis to execute (e.g. primary-sweep)" },
         output_path: { type: "string", description: "Absolute path of the named band to write (register-units/<axis>-band.json)" },
+        qids: { type: "array", items: { type: "string" }, description: "Optional: the qids of the plan entries to run. Only those run, and every other block in the band stays as it is. Leave it out only on the axis's first run: without it every entry on the axis runs again." },
       } },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       handler: guard((a) => doExecutePlan(COOKIE, a, tctx("execute_plan"))),

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

@@ -139,6 +139,7 @@ serve({
         plan_path: { type: "string", description: "Absolute path to the frozen _driver/register-plan.json" },
         axis: { type: "string", description: "The register axis to execute (e.g. primary-sweep)" },
         output_path: { type: "string", description: "Absolute path of the named band to write (register-units/<axis>-band.json)" },
+        qids: { type: "array", items: { type: "string" }, description: "Optional: the qids of the plan entries to run. Only those run, and every other block in the band stays as it is. Leave it out only on the axis's first run: without it every entry on the axis runs again." },
       } },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       handler: guard((a) => doExecutePlan(AUTH, a, tctx("execute_plan"))),

package/driver/engine/mcp/free-tier-server.mjs

@@ -151,7 +151,7 @@ serve({
       description: `Execute the frozen register plan for ONE axis across ${CAPABILITY_OFFICES} and write the named band. One qid per plan entry, spanning both offices — the execution-receipt shape is identical to a single-source provider's.`,
       inputSchema: { type: "object", required: ["plan_path", "axis", "output_path"], properties: {
         plan_path: { type: "string" }, axis: { type: "string" }, output_path: { type: "string" },
-        qids: { type: "array", items: { type: "string" } },
+        qids: { type: "array", items: { type: "string" }, description: "Optional: the qids of the plan entries to run. Only those run, and every other block in the band stays as it is. Leave it out only on the axis's first run: without it every entry on the axis runs again." },
       } },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       handler: guard((a) => doExecutePlan(AUTH, a, tctx("execute_plan"))),

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

@@ -903,7 +903,7 @@ export function buildGatherMcpConfig(groups = [], { sessionKey, agent, runDir, r
     localEntry("register");
     if (!runDir) {
       throw new Error("gather-config: a register server needs the run it is fetching for — record bodies "
-        + "belong to their run since #743, and the box-global ledger is retired (#1390). Pass runDir.");
+        + "belong to their run, and the box-global ledger is retired. Pass runDir.");
     }
   }
   const env = serverEnv({ sessionKey, agent, runDir, recordAxis });

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

@@ -122,7 +122,7 @@ function tellObligations(spec, ledgerJson) {
   writeFileSync(
     obligationsSidecarPath(spec.output_path),
     JSON.stringify({
-      _provenance: `what the seat was TOLD it owed, computed by connotationObligations() from ${basename(spec.output_path)} at the moment the grid tool returned — the same calculation the validator judges with (#426)`,
+      _provenance: `what the seat was TOLD it owed, computed by connotationObligations() from ${basename(spec.output_path)} at the moment the grid tool returned — the same calculation the validator judges with`,
       floor: ob.floor,
       queriesOwed: ob.queries.map((e) => e.query),
       rowsTold,

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

@@ -700,7 +700,7 @@ serve({
             type: "object", required: ["text"],
             properties: {
               text: { type: "string", description: "The result, in one line — what was checked and how it came back." },
-              source_link: { type: "string", description: "An http(s) URL for the page it came from. OMIT it when the source is a SEARCH rather than a page — a citation label in a link destination ships a link to nowhere (#875)." },
+              source_link: { type: "string", description: "An http(s) URL for the page it came from. OMIT it when the source is a SEARCH rather than a page — a citation label in a link destination ships a link to nowhere." },
               internal: { type: "boolean", description: "true marks this an INTERNAL reviewer note; the driver renders the ::p:: marker and the client export strips it." },
             },
           },

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

@@ -86,6 +86,7 @@ serve({
         plan_path: { type: "string", description: "Absolute path to the frozen _driver/register-plan.json" },
         axis: { type: "string", description: "The register axis to execute (e.g. primary-sweep)" },
         output_path: { type: "string", description: "Absolute path of the named band to write (register-units/<axis>-band.json)" },
+        qids: { type: "array", items: { type: "string" }, description: "Optional: the qids of the plan entries to run. Only those run, and every other block in the band stays as it is. Leave it out only on the axis's first run: without it every entry on the axis runs again." },
       } },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       handler: guard((a) => doExecutePlan({ apiKey: API_KEY, base: BASE }, a, tctx("execute_plan"))),

package/driver/engine/mcp/supplemental.mjs

@@ -112,7 +112,7 @@ export function mintSupplementalEntries(axis, proposals, { existingQids = new Se
     // rather than guessed about.
     const owner = typeof p.owner === "string" ? p.owner.trim() : "";
     if (p.owner != null && !owner) { issue("owner, when present, must be a non-empty string"); continue; }
-    if (owner && predicate === "owner") { issue(`predicate "owner" carries the owner name as its term — the owner scope field rides a MARK-TEXT predicate ({predicate:"default", term:"TIKI", owner:"…"})`); continue; }
+    if (owner && predicate === "owner") { issue(`predicate "owner" carries the owner name as its term — the owner scope field rides a MARK-TEXT predicate ({predicate:"default", term:"WAVO", owner:"…"})`); continue; }
     // ── romanization (2026-07-30 review round — the enforcement-without-invitation fix) ────────────
     // Half the live incident's non-Latin deferrals were supp: entries, because the guard's remediation
     // ("supply the romanisation on the entry's romanizedTerms") pointed at a field this proposing

package/driver/engine/mcp/uspto-local-server.mjs

@@ -124,6 +124,7 @@ serve({
         plan_path: { type: "string", description: "Absolute path to the frozen _driver/register-plan.json" },
         axis: { type: "string", description: "The register axis to execute (e.g. primary-sweep)" },
         output_path: { type: "string", description: "Absolute path of the named band to write (register-units/<axis>-band.json)" },
+        qids: { type: "array", items: { type: "string" }, description: "Optional: the qids of the plan entries to run. Only those run, and every other block in the band stays as it is. Leave it out only on the axis's first run: without it every entry on the axis runs again." },
       } },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       handler: guard((a) => doExecutePlan(AUTH, a, tctx("execute_plan"))),

package/driver/enqueue-schema.mjs

@@ -242,14 +242,14 @@ function niceClassErrors(list, label) {
 //   A zero-width joiner makes "IRON\u200DWHISK" render as IRONWHISK and compare unequal to it, so
 //   `selfExclusionOwners` and dedup both miss a mark a human reads as the account's own.
 //
-//   NFD "SIRÈNE" !== NFC "SIRÈNE", so one mark submitted two ways is two matters, two searches, two bills.
+//   NFD "FALCÓN" !== NFC "FALCÓN", so one mark submitted two ways is two matters, two searches, two bills.
 //
 // REFUSED, NOT STRIPPED, for the display-control classes. Silently altering the mark a client asked
 // about is its own defect and a worse one: the deliverable would then name a mark nobody ordered. NFC is
 // the exception because it changes no character a reader can see — it is the same string, spelled once.
 //
 // WHAT THIS DELIBERATELY DOES NOT TOUCH, because an over-broad filter here is worse than the defect:
-//   • ACCENTED AND NON-LATIN LETTERS. SIRÈNE, СOLA and an Arabic or Hebrew mark are all legitimate things
+//   • ACCENTED AND NON-LATIN LETTERS. FALCÓN, СOLA and an Arabic or Hebrew mark are all legitimate things
 //     to clear. The refusal is for explicit direction-OVERRIDE controls, never for letters that happen to
 //     be right-to-left — an Arabic mark contains no U+202x at all.
 //   • HOMOGLYPHS. A Cyrillic ES in СOLA is measured in  and explicitly NOT claimed as a defect;

package/driver/feedback-issues.mjs

@@ -26,7 +26,7 @@ export const BASE_LABELS = ["source:report-feedback", "area:report"];
  * describe, which is triage — the thing this issue forbids. A human adds the real area during triage.
  */
 export const REQUIRED_LABELS = [
-  { name: "source:report-feedback", color: "c5def5", description: "Raised by a reviewing lawyer on a delivered report (#260)." },
+  { name: "source:report-feedback", color: "c5def5", description: "Raised by a reviewing lawyer on a delivered report." },
   { name: "feedback:good", color: "0e8a16", description: "A lawyer marked this finding RIGHT. Not a defect — a confirmation worth keeping." },
   { name: "feedback:bad", color: "b60205", description: "A lawyer marked this finding WRONG. Input for triage, not yet buildable work." },
   { name: "area:report", color: "d4c5f9", description: "The delivered report and what it says." },

package/driver/feedback-store.mjs

@@ -18,7 +18,7 @@
 // disposition — read SERVER-SIDE from the run's own artifacts, never taken from the request. Mark and band
 // come from report-data.json; the disposition comes from findings.json beside it in the same run dir,
 // because report-data.json is the CLIENT cut and stopped serving the engine's placement key. A
-// reader who finds the ordinal now points at `KURENA / Manageable / rebuttable` when the flag says
+// reader who finds the ordinal now points at `KOLEMA / Manageable / rebuttable` when the flag says
 // `BURROWELL / Medium / conceded` knows the run was republished, which is exactly the thing a bare id
 // would have hidden.
 

package/driver/findings-model.mjs

@@ -139,7 +139,7 @@ export const POSITION_REQUIRED_DISPOSITIONS = ["adversarial", "coexistence-partn
 export const OFF_FIELD_GROUNDS = ["different-field", "no-material-risk"];
 // Context notes (A1) — the valid HOME for a knowledge-cited reference that is NOT a fetched-record finding:
 // a famous one-keystroke neighbour kept for diligence per digest.md's "never dropped" rule but with NO
-// register record to ground a finding (e.g. CHROME on a NOVAPULSE clearance). A context note is NEVER a finding
+// register record to ground a finding (e.g. NOVAPULSO on a NOVAPULSE clearance). A context note is NEVER a finding
 // (no composite/level/meters/registration), never drives the rating, and carries no uri — so it cannot
 // launder an ungrounded mark into the findings contract: the F-14 URI guard (validateOwner) stays whole, and
 // "the famous neighbour is never dropped" is honoured HERE rather than via a broken empty-uri finding.
@@ -246,7 +246,7 @@ export function deriveDisplayVerdict({ verdict, reasons, kinds, findings, manife
 }
 
 // ── wp50 — THE deterministic client-summary-block → finding join ────────────────────────────────────────
-// The old first-match substring-containment join mis-bound "DEMVENZY — Novartis" to the VENZY finding
+// The old first-match substring-containment join mis-bound "DEMVENZY — Norvanta" to the VENZY finding
 // (the head CONTAINS "venzy"), so the validator and the lint auto-correct VALIDATED — and would have
 // ENFORCED — the wrong finding's tier, rating two Composite-3 conflicts at the top band. One join,
 // used by the validator, the auto-correct and the email
@@ -728,7 +728,7 @@ const CORRECTION_ENTRY_KEYS = ["entity", "disposition", "note"];
 // blob. The frozen renderer receives a deterministic STRING PROJECTION (projectAssessmentField); the
 // structured rows render in the audit workbook + report-data, both unfrozen.
 // spec 2026-07-30 §3: `read` — the one-to-two-sentence consequence the reader sees ("A weak name to
-// own. SLUSH is simply what the product is, so the whole mark rests on TIKI."). The renderer shows it
+// own. SLUSH is simply what the product is, so the whole mark rests on WAVO."). The renderer shows it
 // as the visible prose and collapses the typed rows behind toggles; absent (archived structured runs)
 // the renderer falls back to spectrum/acquired/note.
 const ASSESSMENT_FIELD_KEYS = ["spectrum", "read", "per_class", "per_market", "counter_registrations", "acquired", "note"];

package/driver/flag-snapshot.mjs

@@ -238,7 +238,7 @@ export function buildFlagSnapshot(env, { capturedAt, registerProvider = null, re
  * reports a delta that does not exist, which is the same class of lie as reporting none.
  */
 export const PRODUCTION_POSTURE = {
-  source: "production unit environment, read 2026-08-04 with owner authorisation (#372); the flag half "
+  source: "production unit environment, read 2026-08-04 with owner authorisation; the flag half "
     + "retired 2026-08-20 when #1149 item 8 deleted every switch it named",
   // The three it named are gone — deleted BECAUSE production ran them on while the source shipped them
   // off, which is the delta this block existed to expose. There is nothing left to differ about, and

package/driver/floor-duty.mjs

@@ -64,8 +64,8 @@ export function armFloorDuty(runDir, { now = () => new Date().toISOString() } =
   try {
     ensureDriverDir(String(runDir ?? ""));
     writeFileSync(driverDir(String(runDir ?? ""), FLOOR_DUTY_STAMP), JSON.stringify({
-      _provenance: "the placement pass on this run ran under code that orders the floors by record id "
-        + "(#1117), so its floor account may be held to that order",
+      _provenance: "the placement pass on this run ran under code that orders the floors by record id"
+        + ", so its floor account may be held to that order",
       ts: now(),
     }, null, 2) + "\n");
     return true;

package/driver/form-neighbourhood.mjs

@@ -33,7 +33,7 @@ import { dominantElementFromManifest, formativeRootFromManifest } from "./scope-
 // mark-restatement check already share (providers/_shared/script-form.mjs — itself PURE, no node
 // imports, so this module stays offline-testable). The floor/model merge below keys on it for the
 // same reason those two do: a private second fold is how two definitions of "the same term" drift.
-import { formKey } from "../providers/_shared/script-form.mjs";
+import { formKey, mixesLatinWithGreekOrCyrillic } from "../providers/_shared/script-form.mjs";
 
 const LOWER = "abcdefghijklmnopqrstuvwxyz";
 const AZ = LOWER.split("");
@@ -87,11 +87,11 @@ export function editNeighbourhood(element) {
 // ── A one-letter neighbour that is an ordinary word with a DIFFERENT SOUND is not searched ────────────
 //
 // THE REVIEWING LAWYER'S TEST IS CONFUSING SIMILARITY, and edit-1 over a short ordinary word is mostly other
-// ordinary words: CARE, CODE, CORD, BORE, MORE beside CORE, each a common mark with its own crowd. Measured
+// ordinary words: BANE, CAGE, CAKE, CAME, LANE beside CANE, each a common mark with its own crowd. Measured
 // on a delivered four-letter run, 2026-09-18: 1,037 of 2,098 records (49%) were reached only by the one-letter
 // lists; on the dense production matter of 2026-09-16, 1,154 of 2,146 (54%). Conceptually different words are
 // not confused by consumers, so fetching them is cost and not coverage. A respelling that sounds the same —
-// KORE for CORE — is exactly what a search must find, and so is every neighbour of a made-up word, because two
+// KANE for CANE — is exactly what a search must find, and so is every neighbour of a made-up word, because two
 // unknown words that sound alike have nothing conceptual to keep them apart (MALENA beside VALENA).
 //
 // So a neighbour is dropped only when BOTH hold: it is in the ordinary-word list, AND no Double-Metaphone key
@@ -101,8 +101,8 @@ export function editNeighbourhood(element) {
 // missing from it is searched: over-search is the safe direction.
 //
 // DOUBLE METAPHONE KEEPS VOWELS ONLY AT THE START, so a vowel change inside the word does not change the key:
-// CARE, CURE and GORE all key KR, as CORE does, and are KEPT. That is the rule as specified erring towards the
-// search, and it is recorded here so nobody reads those three as a defect of the list.
+// CONE and CANOE both key KN, as CANE does, and are KEPT. That is the rule as specified erring towards the
+// search, and it is recorded here so nobody reads those two as a defect of the list.
 //
 // `ordinaryWords` is a Set of lowercase words, or null. Null drops nothing — the behaviour before this rule —
 // so a caller that does not load the list (every test that predates it) is unchanged. PURE.
@@ -259,7 +259,13 @@ export function transliterations(element, { scripts = SUPPORTED_SCRIPTS } = {})
 // droppedVariantFamilies). The floor stays exhaustive WITHIN the families judgment kept — this is the funnel
 // honouring a scope decision that was already written and, until 2026-07-18, ignored. edit-1 is never
 // droppable: it is the doctrine floor (radiusFor), not a family.
-export function formNeighbourhood(element, { markets = [], scripts = SUPPORTED_SCRIPTS, droppedAxes = [], ordinaryWords = null } = {}) {
+//
+// `mixedScriptQuery` is the active register's declaration of the same name (capabilities.js). `false`
+// means the register cannot search a term mixing Latin with Greek or Cyrillic letters as written, so the
+// whole-word look-alike swaps that leave some letters Latin are not searched there: they leave the band
+// and are listed in `mixedScriptNotSearched` instead. Anything else — the value of every register that
+// does not declare it — changes nothing, and the band carries no new field.
+export function formNeighbourhood(element, { markets = [], scripts = SUPPORTED_SCRIPTS, droppedAxes = [], ordinaryWords = null, mixedScriptQuery = null } = {}) {
   const radius = radiusFor(element);
   const el = radius.element;
   if (!el) return { element: "", radius, exactQueries: [], wildcardPatterns: [], phoneticKeys: [], confusables: [], transliterations: [], ordinaryWordDifferentSound: [], ledger: { disclosed: radius.note, axes: [] } };
@@ -272,7 +278,11 @@ export function formNeighbourhood(element, { markets = [], scripts = SUPPORTED_S
   const skip = new Set(notSearched);
   const edits = generatedEdits.filter((t) => !skip.has(t));
   const confs = drop.has("visual-confusable") ? [] : visualConfusables(el);
-  const trans = drop.has("transliteration") ? [] : transliterations(el, { scripts });
+  const generatedTrans = drop.has("transliteration") ? [] : transliterations(el, { scripts });
+  // Only the transliteration generator can write a mixed-alphabet term: edit-1 works over [a-z] and the
+  // confusable table maps Latin to Latin, digits and `@`.
+  const mixedNotSearched = mixedScriptQuery === false ? generatedTrans.filter(mixesLatinWithGreekOrCyrillic) : [];
+  const trans = generatedTrans.filter((t) => !mixedNotSearched.includes(t));
   const wildcards = drop.has("phonetic-family") ? [] : skeletonPatterns(el);
   const keys = drop.has("phonetic-family") ? [] : doubleMetaphone(el).filter(Boolean);
 
@@ -297,6 +307,7 @@ export function formNeighbourhood(element, { markets = [], scripts = SUPPORTED_S
     confusables: confs,
     transliterations: trans,
     ordinaryWordDifferentSound: notSearched,
+    ...(mixedScriptQuery === false ? { mixedScriptNotSearched: mixedNotSearched } : {}),
     ledger: {
       disclosed: radius.note,
       dropped_axes: [...drop].sort(),
@@ -324,7 +335,9 @@ export function formNeighbourhood(element, { markets = [], scripts = SUPPORTED_S
             : keys.length ? `NO PATTERN — "${el}" has too few consonants to anchor a skeleton wildcard, so the family has no retrieval pattern; Double-Metaphone key(s) [${keys.join(",")}] still verify what the other axes return`
             : `NO PATTERN — "${el}" has too few consonants to anchor a skeleton wildcard and yields no Double-Metaphone key, so this axis contributes nothing for this element and verifies nothing` },
         { axis: "visual-confusable", count: confs.length, mechanism: drop.has("visual-confusable") ? "DROPPED — judgment's variant-layer scope decision" : "Unicode-confusable homoglyph + multigraph table" },
-        { axis: "transliteration", count: trans.length, mechanism: drop.has("transliteration") ? "DROPPED — judgment's variant-layer scope decision" : `scoped scripts: ${scripts.join(", ")}` },
+        { axis: "transliteration", count: trans.length,
+          ...(mixedScriptQuery === false ? { generated: generatedTrans.length, not_searched: mixedNotSearched.length } : {}),
+          mechanism: drop.has("transliteration") ? "DROPPED — judgment's variant-layer scope decision" : `scoped scripts: ${scripts.join(", ")}` },
       ],
       total_exact: exactQueries.length,
     },
@@ -388,7 +401,7 @@ export function coverageGaps(band, { dispatched = [], explained = [] } = {}) {
 // exhaustive edit-1 neighbourhood: 1,736 junk exact queries on AquaPlus 2026-07-17, 4,524 on the 07-16 run.
 // Measured 2026-07-18: 10 of 20 recent runs carried one of these. The JSON field is a validated scalar and
 // cannot swallow a sentence.
-export function renderFormNeighbourhoodJson(manifestMd, { markets = [], scripts = SUPPORTED_SCRIPTS, droppedAxes = [], model = null, mark = "", ordinaryWords = null } = {}) {
+export function renderFormNeighbourhoodJson(manifestMd, { markets = [], scripts = SUPPORTED_SCRIPTS, droppedAxes = [], model = null, mark = "", ordinaryWords = null, mixedScriptQuery = null, nativeScriptIndex = null } = {}) {
   const { seeds, seededFrom, rejected } = floorSeeds(manifestMd, { model, mark });
   // The reason travels WITH the throw. It used to say only "the job states no mark", which is one
   // of two causes and not the one that actually fires: a non-Latin mark states a mark perfectly well and
@@ -400,8 +413,8 @@ export function renderFormNeighbourhoodJson(manifestMd, { markets = [], scripts
       || "manifest names no Dominant element / Formative root, and the job states no mark";
     throw new Error(`form_neighbourhood_no_element: ${why} — nothing to seed the mechanical form band`);
   }
-  const elements = seeds.map(({ element, role }) => ({ element, role, band: formNeighbourhood(element, { markets, scripts, droppedAxes, ordinaryWords }) }));
-  const families = variantFloorFamilies(elements, { mark, droppedAxes });
+  const elements = seeds.map(({ element, role }) => ({ element, role, band: formNeighbourhood(element, { markets, scripts, droppedAxes, ordinaryWords, mixedScriptQuery }) }));
+  const families = variantFloorFamilies(elements, { mark, droppedAxes, mixedScriptReason: mixedScriptNotSearchedReason(nativeScriptIndex) });
   return JSON.stringify({
     schema_version: 2,
     generated: "deterministic (model-free) — edit-1 ∪ phonetic-family ∪ visual-confusable ∪ transliteration ∪ spacing-punctuation",
@@ -632,14 +645,27 @@ export function spacingPunctuationForms(mark) {
  * dispatches), assigned to the first family that claims each term — so the family terms sum EXACTLY
  * to what gets searched, never to a parallel list that drifts from it. PURE.
  */
-export function variantFloorFamilies(elements, { mark = "", droppedAxes = [] } = {}) {
+/**
+ * Why the mixed-alphabet look-alikes were not searched, in the terms of what the register's index holds
+ * (`nativeScriptIndex`): a register that indexes the characters answers such a spelling as if its
+ * non-Latin letters were not there; a register that holds non-Latin filings by transliteration only
+ * cannot take the spelling at all. PURE.
+ */
+export function mixedScriptNotSearchedReason(nativeScriptIndex) {
+  return nativeScriptIndex === true
+    ? "not searched — the register answers a mixed-alphabet spelling as if the non-Latin letters were absent (measured 2026-09-23)"
+    : "not searched — the register holds non-Latin filings by their transliteration only, so a mixed-alphabet spelling cannot be searched as written";
+}
+
+export function variantFloorFamilies(elements, { mark = "", droppedAxes = [], mixedScriptReason = mixedScriptNotSearchedReason(true) } = {}) {
   const drop = new Set(droppedAxes ?? []);
   const edit = new Set(), visual = new Set(), translit = new Set(), other = new Set();
-  const wildcards = new Set(), keys = new Set(), notSearched = new Set();
+  const wildcards = new Set(), keys = new Set(), notSearched = new Set(), mixedNotSearched = new Set();
   for (const el of elements ?? []) {
     const band = el?.band;
     if (!band) continue;
     for (const t of band.ordinaryWordDifferentSound ?? []) notSearched.add(t);
+    for (const t of band.mixedScriptNotSearched ?? []) mixedNotSearched.add(t);
     const edits = new Set(editNeighbourhood(el.element));
     const confs = new Set(band.confusables ?? []);
     const trans = new Set(band.transliterations ?? []);
@@ -685,6 +711,12 @@ export function variantFloorFamilies(elements, { mark = "", droppedAxes = [] } =
     ...(notSearched.size ? [{ family: "ordinary-word-different-sound", category: "phonetic", generator: "editNeighbourhood",
       enumeration: "edit-1 neighbours that are ordinary English words and share no Double-Metaphone key with the element",
       dispatch: "not searched — ordinary word, different sound", searched: false, dropped: true, terms: sorted(notSearched) }] : []),
+    // NOT SEARCHED ON THIS REGISTER, listed the same way and kept out of the floor for the same reason.
+    // Present only when the active register declares `mixedScriptQuery: false` (formNeighbourhood).
+    ...(mixedNotSearched.size ? [{ family: "mixed-script-look-alike", category: "transliteration", generator: "transliterations",
+      enumeration: "whole-word Greek and Cyrillic look-alike swaps whose other letters stay Latin",
+      dispatch: mixedScriptReason,
+      searched: false, dropped: true, count: mixedNotSearched.size, terms: sorted(mixedNotSearched) }] : []),
   ];
 }
 
@@ -759,9 +791,9 @@ export function mergeVariantFloor(floorFamilies, modelVariants, { rejectedSeeds
 /**
  * Is `root` a plausible formative root, or a prose-parse artifact?
  *
- * A stem is never LONGER than the element it stems from — SUREN(5) for ZURENA(6), HYDR(4) for HYDRA(5),
+ * A stem is never LONGER than the element it stems from — VOLEM(5) for ZOLEMA(6), HYDR(4) for HYDRA(5),
  * VELTRI(6) for VELTRIN(7). Substring containment is NOT the test: a real root can differ in its leading
- * character (ZURENA → SUREN reaches the ARBORA family), which is exactly the widening the root exists for.
+ * character (ZOLEMA → VOLEM reaches the VOLEMA family), which is exactly the widening the root exists for.
  * The swallowed-sentence artifacts are always the element PLUS a clause — 32-36 characters against a 5-char
  * element — so length alone separates them cleanly without narrowing any legitimate root. PURE.
  */

package/driver/frame-diff-model.mjs

@@ -299,9 +299,9 @@ export function deriveDirectiveRemedy(directive, { dominantElement = "", inScope
   const item = String(d.item ?? "").trim();
   if (!item || !inScopeStr.length) return null;
   // A2 (PR-1, the 2026-07-28 label-as-term class): the item is the directive's display LABEL, and a
-  // label is only usable as a search term when it is mark-shaped. "Reverse-order TIKI composites
-  // (TROPICAL TIKI, ISLAND TIKI)" dispatched verbatim as `exact` is a nil search that reads as a
-  // clean — TROPICAL TIKI and ISLAND TIKI were ONE label, never two terms. The mint would now reject
+  // label is only usable as a search term when it is mark-shaped. "Reverse-order WAVO composites
+  // (TROPICAL WAVO, ISLAND WAVO)" dispatched verbatim as `exact` is a nil search that reads as a
+  // clean — TROPICAL WAVO and ISLAND WAVO were ONE label, never two terms. The mint would now reject
   // it (same shared lint), but the honest ending is decided HERE: no code remedy ⇒ the directive is
   // DISCLOSED (the caller's defer lane), never swept blind. A directive that knows its terms says so
   // in a structured `remedy` (precedence 1 above) — that is the documented fix (SKILL.md).

package/driver/gateway.mjs

@@ -703,7 +703,7 @@ export function syncCoverageForm(files) {
     // was ever observed; this is the report. The axis set is UNCHANGED — filtering it would silently
     // shrink the form, which is worse than the row it would avoid.
     for (const a of (input.unknownAxisUnits ?? []))
-      note(`[coverage-form] register-units carries ${a}.md, which is not one of the register axes — its row is DRIVER-written and a seat cannot repair it. This is a driver fault, not a seat one (#1100).`);
+      note(`[coverage-form] register-units carries ${a}.md, which is not one of the register axes — its row is DRIVER-written and a seat cannot repair it. This is a driver fault, not a seat one.`);
     const prior = readCoverageForm(runDir, formName).rows;
     const u = unionCoverageForm({ rows: prior }, { rows: null }, input);
     // Said out loud on failure rather than swallowed — but UNLIKE this is not the fail-open leg:
@@ -1567,7 +1567,7 @@ async function runStageLadder(name, opts, stageCodexHome = null) {
     // silences the REFUSAL, never the record — `modelActual`/`modelMismatch` keep landing on every row.
     if (modelMismatch === true && !fail && envGateOn("CLEAROTRON_MODEL_WIRE_CHECK")) {
       fail = `model_mismatch:${famRequested}->${famActual}`;
-      note(`[${name}] MODEL MISMATCH: asked for ${modelRequested} (${famRequested}), the wire says ${modelActual} (${famActual}) — failing the turn. An unhonoured model override is an error, not a substitution (#238); every number attributed to this turn would name the wrong model.`);
+      note(`[${name}] MODEL MISMATCH: asked for ${modelRequested} (${famRequested}), the wire says ${modelActual} (${famActual}) — failing the turn. An unhonoured model override is an error, not a substitution; every number attributed to this turn would name the wrong model.`);
     }
 
     // AD-4 house rule — both computed UNCONDITIONALLY, three-valued on purpose:
@@ -1987,7 +1987,7 @@ async function runStageLadder(name, opts, stageCodexHome = null) {
     // falls into the break below, and two rows for one decision would double every count taken off them.
     const cutFired = identicalContent && producedNothing && warm && attempt < maxRetries + 1;
     if (cutFired) {
-      note(`[${name}] attempt ${attempt} [warm patch] reproduced attempt ${attempt - 1}'s failure byte-for-byte and the seat produced NOTHING either time (${fail.slice(0, 140)}) — NOT escalating to a fresh attempt ${attempt + 1}: measured 0 of 6 convergences on this shape (#1062). A seat whose output was merely wrong still escalates.`);
+      note(`[${name}] attempt ${attempt} [warm patch] reproduced attempt ${attempt - 1}'s failure byte-for-byte and the seat produced NOTHING either time (${fail.slice(0, 140)}) — NOT escalating to a fresh attempt ${attempt + 1}: measured 0 of 6 convergences on this shape. A seat whose output was merely wrong still escalates.`);
       // THE CUT IS RECORDED, NOT JUST NOTED. `note` is stderr only (log.mjs) and reaches no artifact, so
       // the run record held no trace of a decision that PREVENTS an attempt — and because the cut
       // returns, the prevented attempt never runs. n=6 would therefore be permanent: a seat or model
@@ -2255,7 +2255,7 @@ export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.jso
     if (/finding_registration_invalid/.test(lastFail)) {
       extra = ` SPECIFIC FIX: a registration.uri is NEVER empty. If this finding has a fetched register record, ` +
         `put its real record URI. If it has NO fetched record (a common-law finding, or a famous mark known only ` +
-        `from general knowledge — e.g. CHROME on a NOVAPULSE clearance), it is NOT a register finding: set ` +
+        `from general knowledge — e.g. KODAK on a CODAK clearance), it is NOT a register finding: set ` +
         `"registrations":[]. And if it is a famous one-keystroke/homophone NEIGHBOUR kept only for diligence, move ` +
         `it OUT of findings[] into the top-level "context_notes" array ({"type":"famous-neighbour-ungrounded",` +
         `"mark","owner","context"}). NEVER invent an empty-uri registration to satisfy the schema.`;
@@ -2675,7 +2675,7 @@ export function correctionHint(lastFail, { gridLedgerName = "common-law-grid.jso
       "Run the CONNOTATION / MEANING sweep — the mark AND its near-forms on the general web (Urban Dictionary, " +
       "Wikipedia, news), query shapes \"[name] gang/slang/offensive/meaning\" — record EVERY query (even " +
       "zero-result ones) into extras.pr_risk, and cite a `Connotation-search source:` line in the PR section. A " +
-      "dictionary gloss is never a clearance (a mark can read as a benign given name yet sit one letter off \"Sureño\", a street-gang label). You may " +
+      "dictionary gloss is never a clearance (a mark can read as a benign given name yet sit one letter off \"Mara\", a street-gang label). You may " +
       "instead report a real connotation hit — but a clean claim needs the search behind it";
   } else if (/named_band_collapsed/.test(lastFail)) {
     const slices = (lastFail.match(/named_band_collapsed:(.+)$/s) || [])[1] || "";

package/driver/jx-lanes.mjs

@@ -252,7 +252,7 @@ export function candidateRefusal(lane, cand) {
 // have always taken it from jx-lanes.
 export { romanizationRefusal, romanizationSpellings };
 
-// ── Billing path for a direct-API jx ledger row ────────────────────────────────────────────
+// ── Billing path for a jx ledger row ──────────────────────────────────────────────────────
 // The jx model calls (fold completions, serp-judge, nativeread) are the ONLY dispatches in the driver
 // that produce a per-token provider invoice. This comment used to name their executor as a
 // `@anthropic-ai/sdk` Messages call; that has not been true since the lane lost its own destination

package/driver/known-conflicts.mjs

@@ -61,6 +61,24 @@ export function canonicalUri(uri) {
   return normalizeRecordUri(uri) || String(uri ?? "").trim();
 }
 
+/**
+ * The recall receipt as ONE company's audit and workbook may list it. Ruled 2026-09-23: the recall
+ * searches keep reading every company's remembered conflicts, so a new company's clearance of a mark
+ * still re-finds them, but no audit or workbook lists a recall check whose source row is another
+ * company's. The line itself says someone cleared this mark before. The receipt names the company the
+ * run is delivered for (`customer`) and each entry the companies whose deliveries remembered it
+ * (`customers`); an entry is listed when one of them is the run's own. A row that names no company
+ * counts only for a run that names none. A receipt written before it named companies lists as it
+ * always did, so an archived run republishes unchanged. Only removes entries; PURE.
+ */
+export function recallReceiptForOwnCompany(receipt) {
+  if (!isPlainObject(receipt) || !Object.hasOwn(receipt, "customer")) return receipt;
+  const own = receipt.customer || null;
+  const mine = (e) => Array.isArray(e?.customers) && e.customers.map((c) => c || null).includes(own);
+  const pick = (xs) => (Array.isArray(xs) ? xs.filter(mine) : xs);
+  return { ...receipt, directives: pick(receipt.directives), overflow: pick(receipt.overflow), refused: pick(receipt.refused) };
+}
+
 const ROW_KEYS = ["uri", "mark_text", "classes", "status", "source", "ts",
   "owner", "jurisdiction", "customer", "opposition_end", "deadline_source_uri", "source_url",
   "terminal"]; // v2 — all optional; v3 adds `terminal` (see acceptedConflicts below)

package/driver/log.mjs

@@ -6,10 +6,10 @@
 import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { dirname, join, basename } from "node:path";
-import { driverDir } from "../shared/driver-dir.mjs";   //
+import { driverDir, RUN_DIR_MODE } from "../shared/driver-dir.mjs";   //
 
 function appendLine(file, obj) {
-  mkdirSync(dirname(file), { recursive: true });
+  mkdirSync(dirname(file), { recursive: true, mode: RUN_DIR_MODE });   // a first log line can be what creates the run folder
   appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), ...obj }) + "\n");
 }
 

package/driver/package.json

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