clearotron 0.4.0 → 0.4.1-beta.0

package/driver/register-plan.mjs

@@ -366,6 +366,15 @@ export const planMaxOrWidth = (capabilities) =>
   Number.isFinite(capabilities?.maxOrWidth) && capabilities.maxOrWidth >= 1
     ? Math.floor(capabilities.maxOrWidth) : PLAN_MAX_OR_WIDTH;
 
+/**
+ * The OR-stack width for an EXACT spelling band. A provider whose general width is narrower than what it
+ * can take for exact spellings declares `exactOrWidth` (signa: one term per request in general, up to 100
+ * exact spellings as one ranked list); every other provider stacks exact spellings at its general width.
+ */
+export const planExactOrWidth = (capabilities) =>
+  Number.isFinite(capabilities?.exactOrWidth) && capabilities.exactOrWidth >= 1
+    ? Math.floor(capabilities.exactOrWidth) : planMaxOrWidth(capabilities);
+
 // The plan emits ONE `wildcard` predicate; the provider contract splits it into three sub-capabilities.
 // Mirrors the executor's planPredicateParams anchoring exactly (trailing * → prefix/starts-with,
 // leading * → suffix/ends-with, both/neither → infix over the raw pattern).
@@ -1111,26 +1120,31 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
   //     anywhere: the exact silent-wrong-query false-clean class this carriage fix exists to kill,
   //     quieter than the loud deferral it replaced. formKey now strips accents from LATIN bases only
   //     and preserves every non-Latin combining mark (width still folds via NFKD).
-  //   - and if two variants STILL share a key while dictating different romanisations (the model
-  //     contradicting itself about one term), the key is poisoned rather than resolved by position:
-  //     those entries compile BARE, and the romanisation-index provider's refusal turns the
-  //     contradiction into a loud disclosed deferral — never into whichever answer came first.
+  //   - and two variants that share a key while dictating DIFFERENT romanisations carry EVERY one of
+  //     them, on every entry for that key. One string of characters can have two readings: the same
+  //     Han characters are read one way in Chinese and another in Japanese, and the manifest lists the
+  //     string once per reading. This rule used to read that as the model contradicting itself and
+  //     compile the key bare, so the romanisation-index provider refused it and the slice reached the
+  //     client as "not searched" — while the model, seeing the refusal, searched both readings as
+  //     supplementals and got its answer (a delivered report, 2026-10-08). Carrying every reading still never
+  //     resolves by position, and never sends a sibling's form in place of the dictated one: each
+  //     reading is asked, in the same request, and a reading that is simply wrong costs one spelling.
   const romanByValue = new Map();
   for (const v of manifest.variants) {
     if (!v.romanization) continue;
     const key = formKey(v.value);
-    const prior = romanByValue.get(key);
-    if (prior === undefined) romanByValue.set(key, v.romanization);
-    else if (prior !== null && romanizationSpellings(prior)[0] !== romanizationSpellings(v.romanization)[0])
-      romanByValue.set(key, null);   // conflicting dictates ⇒ stamp NOTHING for this key (loud backstop)
+    const readings = romanByValue.get(key) ?? [];
+    const reading = romanizationSpellings(v.romanization)[0];
+    if (reading && !readings.some((r) => romanizationSpellings(r)[0].toUpperCase() === reading.toUpperCase()))
+      readings.push(v.romanization);
+    romanByValue.set(key, readings);
   }
   const romanStamp = (e) => {
     // An owner NAME is not mark text and rides its own field (the executor drops the carrier on an
     // owner query anyway). An OR-stack is chunked, not substituted — one non-Latin member must never
     // silently replace a whole chunk's names, so a `terms[]` entry never carries the field.
     if (e.predicate === "owner" || Array.isArray(e.terms)) return {};
-    const roman = romanByValue.get(formKey(e.term));
-    const spellings = roman ? romanizationSpellings(roman) : [];
+    const spellings = [...new Set((romanByValue.get(formKey(e.term)) ?? []).flatMap(romanizationSpellings))];
     return spellings.length ? { romanizedTerms: spellings } : {};
   };
 
@@ -1266,7 +1280,7 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
   // this compiler's own equivalence: `norm` and `formKey` both strip separators, so "BIO VELTRIS",
   // "BIOVELTRIS", "BIO-VELTRIS" and "BIO.VELTRIS" are ONE key. The variant loop below already drops a
   // model variant that restates the mark that way, on exactly that test. Dispatching the generated set
-  // would send the mark's own exact entry three more times under a different spelling — the PARADISE
+  // would send the mark's own exact entry three more times under a different spelling — the Drivers Haven
   // shape (five diacritic terms, same 424 hits, the run's record budget gone), re-imported. The family
   // is enumerated and marked in form-neighbourhood.json because it is genuinely mechanical and the
   // surfaces that do NOT fold spacing are real; wiring it to those is not this change.
@@ -1472,8 +1486,11 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
     const formTerms = [...formBand.exactQueries];
     const latinFormTerms = formTerms.filter((t) => !isNonLatinTerm(t));
     const nativeFormTerms = formTerms.filter((t) => isNonLatinTerm(t));
-    for (let i = 0; i < latinFormTerms.length; i += maxOrWidth)
-      push({ axis: "primary-sweep", predicate: "exact", terms: latinFormTerms.slice(i, i + maxOrWidth), expected_kind: "enumerate", provenance: "floor", qidSuffix: "+form" });
+    // An exact band stacks at the provider's EXACT width, which is wider than its general one where the
+    // register takes a list of exact spellings in one request (planExactOrWidth).
+    const exactWidth = planExactOrWidth(caps);
+    for (let i = 0; i < latinFormTerms.length; i += exactWidth)
+      push({ axis: "primary-sweep", predicate: "exact", terms: latinFormTerms.slice(i, i + exactWidth), expected_kind: "enumerate", provenance: "floor", qidSuffix: "+form" });
     for (const t of nativeFormTerms)
       push({ axis: "primary-sweep", predicate: "exact", term: t, expected_kind: "enumerate", provenance: "floor", qidSuffix: "+form" });
   }
@@ -2173,7 +2190,8 @@ export function validatePlanFeasibility(plan, { capabilities = null, maxOrWidth
     if (!PLAN_PREDICATES.includes(e?.predicate)) add("unexecutable", `unknown predicate "${e?.predicate}"`);
     const names = Array.isArray(e?.terms) ? e.terms : e?.term != null ? [e.term] : [];
     if (!names.length || names.some((t) => !String(t ?? "").trim())) add("unexecutable", "empty term(s)");
-    if (Array.isArray(e?.terms) && e.terms.length > maxOrWidth) add("repairable", `OR-stack of ${e.terms.length} names exceeds the executor bound (${maxOrWidth}) — the executor runs it chunked`);
+    const width = e?.predicate === "exact" && capabilities ? Math.max(maxOrWidth, planExactOrWidth(capabilities)) : maxOrWidth;
+    if (Array.isArray(e?.terms) && e.terms.length > width) add("repairable", `OR-stack of ${e.terms.length} names exceeds the executor bound (${width}) — the executor runs it chunked`);
     for (const t of names) if (String(t).length > maxNameLength) add("repairable", `name exceeds ${maxNameLength} chars ("${String(t).slice(0, 40)}…") — provider-side truncation risk only`);
     if ((e?.nice_classes ?? []).some((c) => !Number.isFinite(Number(c)))) add("unexecutable", "non-numeric nice_class");
     if (e?.when && guardParentQid(e.when) != null && !qids.has(guardParentQid(e.when))) add("unexecutable", `when-guard targets unknown qid "${guardParentQid(e.when)}"`);
@@ -2359,7 +2377,10 @@ export function joinPlanToBands(plan, bandBlocksByAxis, { released = new Set() }
         // and the report's coverage line claims to: it reads "skipped after a broader search came back
         // crowded", which is true when the parent was `incomplete` and false when the parent FAILED or
         // never ran. The state that decides it is read one line above and was thrown away here.
-        if (parentState !== "enumerated") { skipped.push({ qid: e.qid, guard: e.when.runs_if_enumerated, parent_state: parentState || null }); continue; }
+        // AND WHETHER IT ERRED, because the state cannot say: a band has two states, and the executor writes
+        // every provider error as `incomplete` with `error: true` beside it. Read off the state alone, a
+        // broader search that failed was a broader search that crowded.
+        if (parentState !== "enumerated") { skipped.push({ qid: e.qid, guard: e.when.runs_if_enumerated, parent_state: parentState || null, ...(parent?.error === true ? { parent_error: true } : {}) }); continue; }
       }
     }
     const b = byQid.get(e.qid);
@@ -2404,6 +2425,14 @@ export function joinPlanToBands(plan, bandBlocksByAxis, { released = new Set() }
       state: String(b.state ?? "").toLowerCase(),
       records: recs,
       total_hits: Number.isFinite(hits) ? hits : null,
+      // A SLICE THAT RAN AND COULD NOT BE ANSWERED. The executor stamps `deferred: true` with no error on an
+      // owner sweep whose name the register never resolved: the call ran, so it is executed, and the band
+      // says `incomplete` with no count. The deferral is the only thing that tells it from a listing that
+      // overflowed, so it rides with the row rather than stopping at the block.
+      ...(b.deferred === true ? { deferred: true } : {}),
+      // WHAT THE TOTAL COUNTS, when the register said: `records`, one per country a mark covers. Every
+      // reader of this row reads the count as the register's own number (ruled 2026-10-02).
+      ...(typeof b.total_counts === "string" ? { total_counts: b.total_counts } : {}),
     });
   }
   const planQids = new Set(plan.entries.map((e) => e.qid));
@@ -2613,9 +2642,30 @@ export function deriveCoverageSkeleton(plan, join) {
   const deferredQids = new Set((join.deferred ?? []).map((x) => x.qid));
   const awaitingQids = new Set((join.awaiting ?? []).map((x) => x.qid));
   const askedQids = new Set((join.asked ?? []).map((x) => x.qid));
+  // ── A COUNT THE PLAN ALSO READ IN FULL IS NOT A CROWD ──────────────────────────────────────────
+  // A count-only descriptor (the saturation probe's shape) sizes a question and reads none of its
+  // records, so it lands `incomplete` and its axis reads as a crowd. Where another entry asked the
+  // IDENTICAL question — predicate, term, classes, territories, owner and goods — and listed every
+  // record of the same total, nothing the count describes is unread. Leaving the axis `incomplete` told
+  // the reading seat a set was unreviewed that had been read in full, and a delivered report made its
+  // verdict conditional on reviewing it (2026-10-08). Anything short of that stays a crowd.
+  const entryByQid = new Map(plan.entries.map((e) => [e.qid, e]));
+  const question = (e) => (!e || Array.isArray(e.terms) ? null : JSON.stringify([
+    String(e.predicate ?? ""), formKey(String(e.term ?? "")),
+    [...(e.nice_classes ?? [])].map(String).sort(), [...(e.regions ?? [])].map(String).sort(),
+    String(e.owner ?? ""), goodsTermsList(e)]));
+  const readInFull = new Map();
+  for (const x of join.executed) {
+    if (x.state !== "enumerated" || !Number.isInteger(x.total_hits) || x.records !== x.total_hits) continue;
+    const q = question(entryByQid.get(x.qid));
+    if (q) readInFull.set(q, x.total_hits);
+  }
+  const totalByQid = new Map(join.executed.map((x) => [x.qid, x.total_hits]));
+  const readElsewhere = (e) => e.expected_kind === "count" && Number.isInteger(totalByQid.get(e.qid))
+    && readInFull.get(question(e)) === totalByQid.get(e.qid);
   const axes = new Map();
   for (const e of plan.entries) {
-    if (!axes.has(e.axis)) axes.set(e.axis, { axis: e.axis, entries: 0, executed: 0, crowds: 0, missing: [], skipped: 0, deferred: [], awaiting: 0, asked: 0 });
+    if (!axes.has(e.axis)) axes.set(e.axis, { axis: e.axis, entries: 0, executed: 0, crowds: 0, missing: [], skipped: 0, deferred: [], awaiting: 0, asked: 0, readElsewhere: 0 });
     const a = axes.get(e.axis);
     a.entries++;
     // COUNTED BEFORE `skipped`, and separately from it. With the families waiting on every matter this is the ordinary state of
@@ -2631,7 +2681,10 @@ export function deriveCoverageSkeleton(plan, join) {
     // a capability gap is NOT executed — it is a disclosed hole in the axis
     if (deferredQids.has(e.qid)) { a.deferred.push(e.qid); continue; }
     a.executed++;
-    if (stateByQid.get(e.qid) === "incomplete") a.crowds++;
+    if (stateByQid.get(e.qid) === "incomplete") {
+      if (readElsewhere(e)) a.readElsewhere++;
+      else a.crowds++;
+    }
   }
   return [...axes.values()].map((a) => ({
     axis: a.axis,
@@ -2655,6 +2708,7 @@ export function deriveCoverageSkeleton(plan, join) {
     entries: a.entries, executed: a.executed, crowds: a.crowds, skipped: a.skipped, missing: a.missing,
     ...(a.awaiting ? { awaiting: a.awaiting } : {}),
     ...(a.asked ? { asked: a.asked } : {}),
+    ...(a.readElsewhere ? { read_elsewhere: a.readElsewhere } : {}),
     ...(a.deferred.length ? { deferred: a.deferred } : {}),
   }));
 }

package/driver/register-records.mjs

@@ -149,6 +149,9 @@ function toRecord(row, { term, basis, provider }) {
     registrationNumber: row?.registration_number ?? null,
     irNumber: row?.ir_number ?? null,
     filingRoute: row?.filing_route ?? null,
+    // The office's page as the register gave it, where it gave one; publish uses it only when the numbers
+    // above do not address the office's page.
+    officeUrl: row?.office_url ?? null,
     // WHICH QUESTION FOUND IT. Without this a reader cannot tell a filing on the name from a filing on
     // a generated variant, and the two mean very different things to the person deciding on the name.
     matchedForm: term,
@@ -248,6 +251,7 @@ export async function listRegisterRecords({
             classes: scoped, regions, provider, ok, requested: want, fetched,
             total: Number.isFinite(r?.total) ? r.total : null, took_ms: Date.now() - started,
             ...(ok && r?.approximate === true ? { approximate: true, floor: Number.isFinite(r?.floor) ? r.floor : null } : {}),
+            ...(ok && Array.isArray(r?.warnings) && r.warnings.length ? { warnings: r.warnings } : {}),
             ...(ok ? {} : { cause: String(r?.reason ?? "unknown").slice(0, 300) }),
           }) + "\n");
         } catch { /* receipts are best-effort, never fatal */ }
@@ -260,6 +264,9 @@ export async function listRegisterRecords({
         // An approximation is carried as one, exactly as the count lane records it: no number in
         // `total`, the register's floor beside it. Only a provider whose listing states it sets it.
         ...(ok && r?.approximate === true ? { approximate: true, floor: Number.isFinite(r?.floor) ? r.floor : null } : {}),
+        // The register's own notes on this answer, as it sent them — absent when it sent none, which is
+        // not evidence that the answer carried no caveat on a register that sends none at all.
+        ...(ok && Array.isArray(r?.warnings) && r.warnings.length ? { warnings: r.warnings } : {}),
         ...(ok ? {} : { reason: String(r?.reason ?? "the filings could not be fetched").slice(0, 300) }),
       };
     });

package/driver/registry-fidelity.mjs

@@ -1193,8 +1193,8 @@ export function findRegistryArithmeticIssues(text) {
       // most national registers actually do — is TEN YEARS FROM FILING, with registration landing
       // somewhere in between. Two live records from the 2026-07-28 worldwide run, both correct and both
       // failed by the old rule:
-      //   ZA SUPA STICKY  filed 2023-07-12  registered 2025-04-23  expires 2033-07-12  (filing +10)
-      //   PA TAKIS        filed 2023-10-19  registered 2025-04-16  expires 2033-10-19  (filing +10)
+      //   ZA FROSTY GRIP  filed 2023-07-12  registered 2025-04-23  expires 2033-07-12  (filing +10)
+      //   PA WAVA         filed 2023-10-19  registered 2025-04-16  expires 2033-10-19  (filing +10)
       // It blocked delivery of a finished report — "expiry 2033 is not a 10-year cycle from claimed
       // registration 2025" — over data that was right. So the cycle may anchor on EITHER year when both
       // are stated; an expiry that fits neither is still a real arithmetic fault and still fails.

package/driver/repairs.mjs

@@ -708,7 +708,7 @@ export function decideRecovery({ failClass, sig, reason = "", history = [], prio
   // the literal remedy for a provider that is down or refusing, so the second occurrence earns the
   // next rung. Everything else keeps repeat-terminal:
   //   transient-but-wedged — nonzero_exit, unparseable_json, lane_wedge, a stage that times out every
-  //           time: a byte-identical repeat means it is stuck, and three parks is the Wilderness shape
+  //           time: a byte-identical repeat means it is stuck, and three parks is the Open Country shape
   //   stale — the remedy is a deterministic recompute; if the recompute did not settle it, running
   //           it again cannot (the real fix for the observed stale kill is restamping, not retries)
   //   unknown — its one fresh sample already failed identically, so it has disproved itself

package/driver/report-card-record.mjs

@@ -110,9 +110,9 @@ export function findingsDocFor(runDir, ordinal) {
 // "jurisdiction"}` — there is no `register` and no `number`, on any record, ever. So both fallbacks
 // fired on every card and the composed bullet read
 //
-//     - Source: [register-euipo · /mark/eu/018575624](https://euipo.europa.eu/…)
+//     - Source: [register-euipo · /mark/eu/099999992](https://euipo.europa.eu/…)
 //
-// where the corpus it replaced reads `- Source: [EUIPO · 018575624](…)`. An internal enum token and an
+// where the corpus it replaced reads `- Source: [EUIPO · 099999992](…)`. An internal enum token and an
 // internal URI path, in the one line of a client-facing card whose job is to say which register holds
 // the record and under what number. publish/index.mjs quotes the correct shape verbatim in a comment of
 // its own, which is what makes the divergence provable rather than a matter of taste.
@@ -122,7 +122,7 @@ export function findingsDocFor(runDir, ordinal) {
 // delivered report.md" — and writing it is what caught this. The guard now lives beside the code it checks, and
 // this is the argument for building the guard an issue asks for even when the code already looks done.
 //
-// THE NUMBER comes off the URI's last segment: `/mark/eu/018575624` → `018575624`. That is a parse, and
+// THE NUMBER comes off the URI's last segment: `/mark/eu/099999992` → `099999992`. That is a parse, and
 // a parse is what this file exists to avoid — but the alternative is a field that does not exist, and
 // the URI's shape is the driver's own (`/mark/<jurisdiction>/<id>`, dictated in gateway.mjs and bound
 // from the fetched record). A URI that does not match it yields NO number rather than a wrong one, and
@@ -136,7 +136,7 @@ export function findingsDocFor(runDir, ordinal) {
 // against evidence that does not exist.
 const REGISTER_OFFICE = Object.freeze({ "register-euipo": "EUIPO" });
 
-/** The registration number inside a driver record URI (`/mark/eu/018575624`), or `""`. PURE. */
+/** The registration number inside a driver record URI (`/mark/eu/099999992`), or `""`. PURE. */
 export function registrationNumber(uri) {
   const m = /^\/mark\/[a-z]{2}\/([A-Za-z0-9._-]+)$/.exec(str(uri));
   return m ? m[1] : "";

package/driver/scope-facts.mjs

@@ -77,9 +77,12 @@ export function deriveScopeFacts({ instructedScope = null, plan = null, planExec
   // nothing. This reader took the state and dropped the number, and the coverage line then described a
   // slice that found nothing as one that "returned more records than could be listed in full".
   const hitsByQid = new Map((planExecution?.executed ?? []).map((x) => [x.qid, Number.isFinite(x.total_hits) ? x.total_hits : null]));
+  // A slice that ran and that the executor deferred: the register could not answer it (an owner name it never
+  // resolved), which is positive evidence it was not an overflow. See the producer.
+  const deferredExecutedSet = new Set((planExecution?.executed ?? []).filter((x) => x?.deferred === true).map((x) => x.qid));
   const missingSet = new Set(planExecution?.missing ?? []);
   // The skip's own reason: why the broader search did not enumerate. See the producer.
-  const skippedByQid = new Map((planExecution?.skipped ?? []).map((x) => [x.qid, String(x.parent_state ?? "")]));
+  const skippedByQid = new Map((planExecution?.skipped ?? []).map((x) => [x.qid, { state: String(x.parent_state ?? ""), error: x.parent_error === true }]));
   const skippedSet = new Set(skippedByQid.keys());
   const deferredByQid = new Map((planExecution?.deferred ?? []).map((x) => [x.qid, String(x.reason ?? "")]));
   // A WAITING FAMILY THAT NEVER BECAME A SEARCH OF ITS OWN LEAVES THE COUNT. One the reading turn asked
@@ -131,8 +134,11 @@ export function deriveScopeFacts({ instructedScope = null, plan = null, planExec
         // AN ABSENT STATE IS NOT EVIDENCE, and this is the same trap as the count below: a receipt written
         // before the producer carried the parent's state says nothing about why, and reading its silence as
         // a failure would relabel every archived run's skips. Silence leaves the line as it was.
+        //
+        // AND `incomplete` IS NOT EVIDENCE OF A CROWD ON ITS OWN: the executor writes a provider error as an
+        // `incomplete` band with `error: true` beside it, and the producer now carries that flag with the skip.
         const parent = skippedByQid.get(e.qid);
-        if (parent && parent !== "incomplete") a.skipped_after_failure++;
+        if (parent && (parent.error || (parent.state && parent.state !== "incomplete"))) a.skipped_after_failure++;
         continue;
       }
       if (missingSet.has(e.qid)) { a.missing.push(e.qid); continue; }
@@ -170,7 +176,9 @@ export function deriveScopeFacts({ instructedScope = null, plan = null, planExec
           // rather than too much. Only a MEASURED zero demotes it: a null is a count that could not be
           // taken, which is not evidence either way, and reading absence as evidence is the defect this
           // whole file keeps meeting.
-          if (hitsByQid.get(e.qid) === 0) a.incomplete_found_nothing++;
+          // An owner sweep the executor deferred is the same fact reached another way: the register could not
+          // resolve the name, so the search found nothing to list, and there is no count to measure.
+          if (hitsByQid.get(e.qid) === 0 || deferredExecutedSet.has(e.qid)) a.incomplete_found_nothing++;
         }
       } else {
         // a plan entry in NO execution bucket is UNACCOUNTED — the fail-closed reading is "missing"

package/driver/search-policy.mjs

@@ -1165,7 +1165,26 @@ export function countJobMarks(job) {
 // The mark → filesystem-key derivation (research payloads, fixtures). ONE definition — the knockout
 // lane keys per-mark artifacts on it, so two batch marks that collide here ("MOTO X" / "MOTO-X") would
 // silently share a research payload; every door checks collisions with THIS function.
-export const kebab = (s) => String(s ?? "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "mark";
+//
+// THE KEY IS UNIQUE FOR TWO NAMES THAT DIFFER IN ANY LETTER OR NUMBER, in any script. The readable part
+// keeps only `a-z0-9`, because the key is also a report route segment. It used to be the whole key, so
+// every name written wholly in Greek, Cyrillic or Han keyed as `mark`, and two different names of that
+// kind were refused as duplicates at intake; two Latin names differing only in an accented letter merged
+// the same way. A name whose letters and numbers the readable part does not hold in full now carries a
+// short hash of them, NFKC-folded and lowercased. Spacing, punctuation, symbols and case still change
+// nothing, so a true duplicate still collides. A name the readable part already held in full keys exactly
+// as before, byte for byte: research payloads, published report files and per-name links were keyed on it.
+// SYMBOLS GO BEFORE THE FOLD. NFKC turns ™ into "TM" and ℠ into "SM", which would move "BRAND™" off the key
+// it shares with "BRAND"; symbols are the only class NFKC turns into letters or numbers, so dropping them
+// first leaves the fold acting on letters and numbers alone.
+const asciiKey = (s) => String(s ?? "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+const nameLetters = (s) => String(s ?? "").replace(/\p{S}/gu, "").normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "");
+export const kebab = (s) => {
+  const ascii = asciiKey(s);
+  const letters = nameLetters(s);
+  if (letters === ascii.replace(/-/g, "")) return ascii.slice(0, 60) || "mark";
+  return `${(ascii || "mark").slice(0, 51).replace(/-+$/, "")}-${createHash("sha256").update(letters).digest("hex").slice(0, 8)}`;
+};
 export function kebabCollisions(names) {
   const seen = new Map(); const out = [];
   for (const n of names ?? []) {

package/driver/skills/clearance-common-law/SKILL.md

@@ -137,7 +137,7 @@ they render as nothing: no reader ever sees them.
 not need to match the template's wording, and you will not be failed for choosing different words.
 
 ```markdown
-# Common-law findings — Dawn: Legends of Thornmantle (2026-05-11)
+# Common-law findings — Dusk: Tales of Thornmantle (2026-05-11)
 
 ## Summary
 
@@ -146,7 +146,7 @@ not need to match the template's wording, and you will not be failed for choosin
 - Findings surfaced: 12 risk-relevant + 3 competitor intel + 1 PR risk
 - Open verification flags: 2
 
-## Findings — Mark: Dawn: Legends of Thornmantle
+## Findings — Mark: Dusk: Tales of Thornmantle
 <!-- clearotron:section=findings -->
 
 ### Consumer-confusion risks (gaming-industry overlap)
@@ -155,24 +155,24 @@ For game-title rows, the `developer_of_record` and `publisher_of_record` columns
 
 | Finding | Source / Platform | URL | developer_of_record | publisher_of_record | Type | Notes |
 |---|---|---|---|---|---|---|
-| "Chronicles of Ember" | Steam | https://... | Dreamatrix | Topware Interactive | Direct conflict — similar gaming title | "Mostly negative" reviews; commercially active 2013/2015 |
-| "Thornmantle" | itch.io | https://... | Thornfall Games | not extracted | Direct conflict — identical game-title | Single-player adventure, "made for SAE Studio 2 Home Brief"; little online presence; not reviewed in 7 years |
+| "Tales of Dusk" | Steam | https://... | Glimmerhouse | Northgale Interactive | Direct conflict — similar gaming title | "Mostly negative" reviews; commercially active 2013/2015 |
+| "Thornmantle" | itch.io | https://... | Thornfall Games | not extracted | Direct conflict — identical game-title | Single-player adventure made for a game-design course brief; little online presence; not reviewed in 7 years |
 | "Thornmantle: Of Magic and Power" | Moby Games | https://... | not extracted | not extracted | Direct conflict — historical gaming title | Released 2007; status unavailable; verify-publisher flag set |
-| "Thornmantle" Astragate ARPG | News / web | https://... | Astragate | not extracted | Direct conflict — gaming title | Browser game; appears cancelled |
-| "Ysolde the Thornmantle" | Pathfinder wiki | https://... | N/A | Grimtable Press | Conceptual — deity name in tabletop RPG | Tabletop, not video game; commercial risk in RPG space |
+| "Thornmantle" Starhollow ARPG | News / web | https://... | Starhollow | not extracted | Direct conflict — gaming title | Browser game; appears cancelled |
+| "Ysolde the Thornmantle" | tabletop RPG wiki | https://... | N/A | Grimtable Press | Conceptual — deity name in tabletop RPG | Tabletop, not video game; commercial risk in RPG space |
 
 ### Commercial awareness (identical/similar in unrelated fields)
 
 | Finding | Source / Platform | URL | Notes |
 |---|---|---|---|
-| "Raising Your Play" | HP marketing | https://... | HP uses tagline for gaming hardware; no register protection found (flagged for clearance-register cross-check) |
-| 1,600+ "Dawn" titles on Steam | Steam | https://... | Crowded field — supportive evidence |
+| "Raising Your Play" | Brightwick marketing | https://... | Brightwick uses tagline for gaming hardware; no register protection found (flagged for clearance-register cross-check) |
+| 1,600+ "Dusk" titles on Steam | Steam | https://... | Crowded field — supportive evidence |
 
 ### Competitor intelligence
 
 | Finding | Source / Platform | URL | Notes |
 |---|---|---|---|
-| Sony "Pulse Elevate" portfolio | Sony products | https://... | Sony uses "Elevate" in audio products; flagged for clearance-register cross-check |
+| Veltrona "Pulse Raise" portfolio | Veltrona products | https://... | Veltrona uses "Raise" in audio products; flagged for clearance-register cross-check |
 | Foxglade "Borealis" console "Raise Your Play" tagline (prior usage) | Foxglade Interactive marketing | https://... | Client's own prior use — note as supportive |
 
 ### PR / reputational risk
@@ -187,7 +187,7 @@ means *blackberry*" is context, not a clearance: a connotation reads clean only
 
 | Finding | Source | Notes |
 |---|---|---|
-| meaning readings surfaced | Urban Dictionary / Wikipedia / news / forums | per form, the readings the search returned + benign/loaded label — e.g. `ELEVATE → ordinary verb "raise" (benign)`; near-forms `RAIZE / RAYSE → no slang/gang/offensive reading`. Write `(None identified)` as the *bottom line* only after the readings are laid out and none is loaded. |
+| meaning readings surfaced | Urban Dictionary / Wikipedia / news / forums | per form, the readings the search returned + benign/loaded label — e.g. `RAISE → ordinary verb "lift" (benign)`; near-forms `RAIZE / RAYSE → no slang/gang/offensive reading`. Write `(None identified)` as the *bottom line* only after the readings are laid out and none is loaded. |
 
 A clean PR/connotation row MUST cite its search — add a `**Connotation-search source:** <URL | "perplexity_research — no result">` line. The driver dictates the meaning sweep into the grid (the matter frame's meaning questions) and the plugin records every query into the ledger's `extras.pr_risk[]`; the `commonLaw` validator rejects a `(None identified)` claim with no recorded queries (`connotation_search_missing`). An empty-results search is a clean receipt; a *missing* search is not.
 
@@ -340,13 +340,13 @@ forms (and the gap form) — this is what the driver's receipt gate counts:
 
 | Variant | Platform | Result |
 |---|---|---|
-| Dawn: Legends of Thornmantle | Steam | No results |
-| Dawn: Legends of Thornmantle | Epic Games Store | No similar listings (6 candidates reviewed) |
-| Dawn: Legends of Thornmantle | Google Play | No results |
-| Dawn: Legends of Thornmantle | Apple App Store | No similar listings (3 candidates reviewed) |
-| Dawn: Legends of Thornmantle | Microsoft Store | No results |
-| Dawn: Legends of Thornmantle | itch.io | Similar listing(s) found — see Findings (2 candidates) |
-| Dawn: Legends of Thornmantle | web | No similar listings (8 candidates reviewed) |
+| Dusk: Tales of Thornmantle | Steam | No results |
+| Dusk: Tales of Thornmantle | Epic Games Store | No similar listings (6 candidates reviewed) |
+| Dusk: Tales of Thornmantle | Google Play | No results |
+| Dusk: Tales of Thornmantle | Apple App Store | No similar listings (3 candidates reviewed) |
+| Dusk: Tales of Thornmantle | Microsoft Store | No results |
+| Dusk: Tales of Thornmantle | itch.io | Similar listing(s) found — see Findings (2 candidates) |
+| Dusk: Tales of Thornmantle | web | No similar listings (8 candidates reviewed) |
 | エバーライト | Steam | not executed — coverage-limited (see ledger) |
 
 ### Coverage ledger (feeds synthesis coverage-honesty + skeptic audit)
@@ -366,8 +366,8 @@ Record the same statuses by calling `record_coverage_status`, passing `grid_spec
 
 | Trigger | Suggested cross-check |
 |---|---|
-| HP appears using "RAISING YOUR PLAY" | Check register: does HP have any elevate-related trademark in target classes? |
-| Sony "Pulse Elevate" portfolio | Check register: any Sony elevate filings in target classes? |
+| Brightwick appears using "RAISING YOUR PLAY" | Check register: does Brightwick have any raise-related trademark in target classes? |
+| Veltrona "Pulse Raise" portfolio | Check register: any Veltrona raise filings in target classes? |
 | Thornfall Games "Thornmantle" (itch.io) | Check register: any Thornfall trademark protection? |
 
 ### Audit trail
@@ -377,8 +377,8 @@ Record the same statuses by calling `record_coverage_status`, passing `grid_spec
 |---|---|---|---|
 | 1 | Grid (sandbox) | Search-as-code grid: 9 variants × 7 platforms + extras | 63 cells, 0 gaps, 487 candidates recorded; 12 risk-relevant after judgment |
 | 2 | Famous-mark | None flagged in manifest | (not run) |
-| 3 | Follow-up | HP gaming portfolio + "raising your play" deeper trace | 3 additional findings |
-| 4 | Follow-up | Sony pulse-elevate portfolio | 2 additional findings |
+| 3 | Follow-up | Brightwick gaming portfolio + "raising your play" deeper trace | 3 additional findings |
+| 4 | Follow-up | Veltrona pulse-raise portfolio | 2 additional findings |
 
 **Grid program receipt** — the executed sandbox program returned by the tool, verbatim:
 
@@ -389,7 +389,7 @@ Record the same statuses by calling `record_coverage_status`, passing `grid_spec
 ### Open verification flags
 
 - Thornfall Games "Thornmantle" itch.io listing — URL needs re-verification (404'd during follow-up call)
-- HP "Raising Your Play" marketing presence in EU — coverage was thin, may need a region-specific follow-up
+- Brightwick "Raising Your Play" marketing presence in EU — coverage was thin, may need a region-specific follow-up
 ```
 
 ## Process

package/driver/skills/clearance-register/digest.md

@@ -135,8 +135,8 @@ drop can be neither examined nor audited. Batching stays correct for *retrieval*
 enumeration, `_query` attribution); it is only forbidden as a unit of dismissal.
 
 One entry, one record, one reason. A `drop_reason` is the judgment alone — the uri, verdict, class and
-status are rendered beside it: `dropped — off-field (relevance gate): DAWN-only hit; the
-descriptive-compound risk theory retains DAWN-only hits only in gaming, and this is film production`.
+status are rendered beside it: `dropped — off-field (relevance gate): DUSK-only hit; the
+descriptive-compound risk theory retains DUSK-only hits only in gaming, and this is film production`.
 
 ### Dominant-element reconciliation (driver-gated — every screened composite ENDS somewhere)
 
@@ -435,7 +435,7 @@ read. Keep if plausibly on-point; drop only genuine field-irrelevance, or a near
 | Archetype | Keep when | Drop when |
 |---|---|---|
 | **Coined word** | Mark text contains a phonetic/visual neighbour of the coined element; or is the coined element exact-match | Mark text shares only an unrelated real-word token via tokenisation (e.g., searching coined THORNMANTLE and surfacing a mark whose only overlap is a "LIGHT" token) |
-| **Descriptive compound** | Mark contains the distinctive anchor; OR is an identical/near-identical compound-phrase match; OR is a single-element registered mark on a common element with goods/services in the target field | Mark is a 5+ element compound that happens to share one common token (e.g., a film studio's "DAWN OF JUSTICE" filing surfaced when searching "Dawn: Legends of Thornmantle" — DAWN is common, surrounding context unrelated) |
+| **Descriptive compound** | Mark contains the distinctive anchor; OR is an identical/near-identical compound-phrase match; OR is a single-element registered mark on a common element with goods/services in the target field | Mark is a 5+ element compound that happens to share one common token (e.g., a film studio's "DUSK OF VALOR" filing surfaced when searching "Dusk: Tales of Thornmantle" — DUSK is common, surrounding context unrelated) |
 | **Slogan** | Mark matches the slogan structure (same template, same semantic field, family-pattern hit, verb-swap, slang variant, co-brand wildcard); OR is the unique distinctive token of the slogan if any | Single-word hit on a slogan element in an unrelated context (DAWN alone surfaced when searching "DAWN OF NEW DAY" slogan); slogan in a wildly different semantic field with no template overlap |
 | **Acronym / initialism** | Mark text contains the letter string in target classes; OR is the expansion form of the acronym | Random word that happens to contain the letters as a substring of a longer word |
 | **Device-led** (modifier) | Standard tests for primary archetype, plus visual similarity per design-code search | Pure-text noise with no visual signal |

package/driver/skills/clearance-register/register-recipes.md

@@ -46,13 +46,13 @@ the cross-cutting relevance / sufficiency / owner-aggregation / prioritisation o
 
 ## Recipe 1 — Compound tagline (multi-word mark with distinctive element)
 
-**When to use:** mark has 3+ words where 1 element is distinctive and the others are common (e.g., "Dawn: Legends of Lumengarde" — LUMENGARDE distinctive, DAWN + LEGENDS common).
+**When to use:** mark has 3+ words where 1 element is distinctive and the others are common (e.g., "Dusk: Tales of Lumengarde" — LUMENGARDE distinctive, DUSK + TALES common).
 
 **Pattern:**
 
 ```
 1. Crowd descriptor — count-only probe each saturated common element (limit=1, fields=[uri])
-   → name:DAWN classes 9,28,41,42 → write an `incomplete` crowd-descriptor block (count + reason)
+   → name:DUSK classes 9,28,41,42 → write an `incomplete` crowd-descriptor block (count + reason)
    → name:LEGEND classes 9,28,41,42 → write an `incomplete` crowd-descriptor block
    (these enumerate nothing — they describe the crowd for judgment)
 
@@ -60,11 +60,11 @@ the cross-cutting relevance / sufficiency / owner-aggregation / prioritisation o
    → name:LUMENGARDE classes 9,28,41,42 → enumerated|incomplete block (every record carried forward)
 
 3. ENUMERATE each common element as a named query in the in-scope classes
-   → name:DAWN match=exact classes 9,28,41,42  → register_enumerate (exact-in-class name-list)
+   → name:DUSK match=exact classes 9,28,41,42  → register_enumerate (exact-in-class name-list)
    → name:LEGEND match=exact classes 9,28,41,42 → register_enumerate
 
 4. ENUMERATE the compound phrase
-   → name:"Dawn: Legends of Lumengarde" match=phrase classes 9,28,41,42 → register_enumerate
+   → name:"Dusk: Tales of Lumengarde" match=phrase classes 9,28,41,42 → register_enumerate
 
 5. ENUMERATE a cross-class merch query if any identical match
    → name:<exact mark> match=exact classes 25 → register_enumerate
@@ -168,11 +168,11 @@ For each transliteration variant in the manifest:
 
 ```
 1. Crowd descriptors — count-only probes on the saturated common elements (limit=1, fields=[uri])
-   → name:ELEVATE classes 9/28/41/42 → `incomplete` crowd-descriptor block
-   → name:GAME classes 9/28/41/42 → `incomplete` crowd-descriptor block
+   → name:RAISE classes 9/28/41/42 → `incomplete` crowd-descriptor block
+   → name:PLAY classes 9/28/41/42 → `incomplete` crowd-descriptor block
 
 2. Crowd descriptor — partial-phrase prefix count (the narrative anchor)
-   → phrase:"ELEVATE YOUR" classes <target> limit=1 → `incomplete` block ("234 live ELEVATE YOUR ___")
+   → phrase:"RAISE YOUR" classes <target> limit=1 → `incomplete` block ("234 live RAISE YOUR ___")
 
 3. ENUMERATE the compound phrase, 3 match-modes (register_enumerate each)
    → exact:"RAISE YOUR PLAY" classes <target>   → identical-mark band
@@ -186,12 +186,12 @@ For each transliteration variant in the manifest:
    → ...
 
 5. ENUMERATE wildcard variant queries (per manifest)
-   → name:"Elevate * game" classes <target>     → register_enumerate
-   → name:"Elevate your *"  classes <target>     → register_enumerate
-   → name:"* your game"     classes <target>     → register_enumerate
+   → name:"Raise * play"  classes <target>     → register_enumerate
+   → name:"Raise your *"   classes <target>     → register_enumerate
+   → name:"* your play"     classes <target>     → register_enumerate
 
 6. ENUMERATE each common element's exact-in-class name-list (register_enumerate)
-   → name:ELEVATE match=exact classes <target>  (scope by CLASS + REGION, not a product/goods term)
+   → name:RAISE match=exact classes <target>  (scope by CLASS + REGION, not a product/goods term)
 
 7. ENUMERATE a cross-class merch query if identical match
 ```

package/driver/skills/clearance-register/status-rules.md

@@ -143,7 +143,7 @@ The order matters. Specifically:
 | `"PLAYVERSE LEVEL UP GAMING"` | `"Level up together"` | false |
 | `"It's Your Play"` | `"In Your Play"` | false (apostrophe matters) |
 
-These fixtures should be encoded in test cases for any agent or analyzer implementing the rule. Worked example for the "Dawn: Legends of Lumengarde" matter: "Dawn: Legends of Lumengarde" ≡ "DAWN LEGENDS OF LUMENGARDE" ≡ "dawn legends of lumengarde" — all identical. "Dawn of Lumengarde" or "Dawn: Legends" — NOT identical.
+These fixtures should be encoded in test cases for any agent or analyzer implementing the rule. Worked example for the "Dusk: Tales of Lumengarde" matter: "Dusk: Tales of Lumengarde" ≡ "DUSK TALES OF LUMENGARDE" ≡ "dusk tales of lumengarde" — all identical. "Dusk of Lumengarde" or "Dusk: Tales" — NOT identical.
 
 ## Chinese status strings
 

package/driver/skills/clearance-register/unit.md

@@ -150,7 +150,7 @@ band its plan entries call for is missing is refused as `named_band_missing`.
 ### Per-axis specifics
 
 - **`saturation-probe`** — fires when any element is flagged `saturation: high`/`very-high`, plus a partial-phrase structural-prefix probe for slogan/descriptive-compound multi-word marks. Run count-only probes (`limit:1, fields:["uri"]`) capturing `total_hits`, and write **one `incomplete` crowd-descriptor block per probed element** (`fetched:0`, `reason:"crowd descriptor — saturated element <X>, count-only"`). It measures how crowded an element is — it **enumerates nothing and clears nothing**. Skip (not applicable) if all elements are distinctive/low-saturation. **A meaning-translation variant (`translit-*-meaning`) is NOT special-cased into a drop:** an everyday-word-scale count is just a crowd descriptor; whether the field-scoped named slice inside it matters is judgment's call — the funnel surfaces the count, and the **primary-sweep** axis runs the field-scoped named enumeration where the frame says that market matters (see `transliteration-numeric`). Record `translit-too-generic` in the descriptor `reason` as a context note (NOT a drop / re-narrow / swap-to-phonetic signal). An implausibly LOW count on a translation that ought to have peers is the separate `translit-underretrieved` context note — also recorded in the descriptor `reason`, never acted on as a drop. Both are signals the lawyer reads.
-- **`primary-sweep`** — always applicable. Run the playbook's named variant queries: the exact mark + each `phrase-substitution`, `visual-substitution`, family-pattern wildcard, and slang variant the manifest lists, **each via `register_enumerate`** (the tool guarantees the page loop). Owns the family-pattern / phrase-substitution / slang / visual-substitution variant queries. **Owns the dead-inclusive named enumeration** (its `register_enumerate` calls carry live AND dead records forward with their status — see step 6; there is no separate "dead-but-identical" or "D4" pass, because the funnel no longer filters dead records). **On a saturated unit, owns the [named-band enumeration of the dangerous category](#exact-in-class-live-floor-primary-sweep-unit-owns-it)** (the exact mark + the **distinctive** formative root / dominant token as the substring-in-scope-class-live named slice, per major+material jurisdiction, plus the phonetic fringe) — enumerated, not sampled. **The named enumeration covers a saturated `translit-*-meaning` meaning token too, where the frame says that market matters (see `transliteration-numeric`)** (scoped to the filed in-scope Nice classes as the `nice_classes` × `regions` filter on the `register_enumerate` call, NOT goods-words ANDed into the search text) — not only the Latin dominant element / formative root. **But a COMMON component that is NOT the distinctive anchor** (a "stripped" common word the manifest marks common/descriptive — DAWN / LEGENDS / GREAT / OUTDOORS) **is count-only, owned by `saturation-probe`, and is NOT enumerated here**: `saturation-probe` already counts it and hands that count up; primary-sweep does **not** run the substring / per-major / phonetic enumeration on it and does **not** author a second crowd block for it (see the linked section — wholesale-enumerating a common component per-jurisdiction is the mega-crowd grind that SIGKILLs the stage).
+- **`primary-sweep`** — always applicable. Run the playbook's named variant queries: the exact mark + each `phrase-substitution`, `visual-substitution`, family-pattern wildcard, and slang variant the manifest lists, **each via `register_enumerate`** (the tool guarantees the page loop). Owns the family-pattern / phrase-substitution / slang / visual-substitution variant queries. **Owns the dead-inclusive named enumeration** (its `register_enumerate` calls carry live AND dead records forward with their status — see step 6; there is no separate "dead-but-identical" or "D4" pass, because the funnel no longer filters dead records). **On a saturated unit, owns the [named-band enumeration of the dangerous category](#exact-in-class-live-floor-primary-sweep-unit-owns-it)** (the exact mark + the **distinctive** formative root / dominant token as the substring-in-scope-class-live named slice, per major+material jurisdiction, plus the phonetic fringe) — enumerated, not sampled. **The named enumeration covers a saturated `translit-*-meaning` meaning token too, where the frame says that market matters (see `transliteration-numeric`)** (scoped to the filed in-scope Nice classes as the `nice_classes` × `regions` filter on the `register_enumerate` call, NOT goods-words ANDed into the search text) — not only the Latin dominant element / formative root. **But a COMMON component that is NOT the distinctive anchor** (a "stripped" common word the manifest marks common/descriptive — DUSK / TALES / GREAT / OUTDOORS) **is count-only, owned by `saturation-probe`, and is NOT enumerated here**: `saturation-probe` already counts it and hands that count up; primary-sweep does **not** run the substring / per-major / phonetic enumeration on it and does **not** author a second crowd block for it (see the linked section — wholesale-enumerating a common component per-jurisdiction is the mega-crowd grind that SIGKILLs the stage).
 - **`transliteration-numeric`** — fires when the manifest has `translit-*` variants or numeric-substitution variants. Ask one script question per market the frame names. Where the register files foreign marks by their romanised form, and it says so, the Latin question already covers them; do not ask it again in other scripts. A word's meaning in another language is asked only where the frame says that market matters and buyers would read the word as the mark. For each numeric-substitution variant enumerate its query. Owns the foreign-transliteration + numeric-substitution variant queries. Skip if the manifest classifies the mark English-only / single-language. (Multi-script accumulation is no longer a window risk for the unit — `register_enumerate` owns the page loop and a crowd returns `incomplete`, so the unit does not deep-page raw rows itself.)
 - **`incumbent-class`** — fires when the manifest has an `industry_incumbent_alert`. `register_enumerate` the named band in the matter's in-scope Nice set and markets — **never an all-class incumbent sweep** (that is the unscoped crowd that timed this very axis out live). **Beyond the NAMED watchlist incumbents, the named enumeration is an UNNAMED-OWNER exact-in-class-live enumeration in those classes** — the watchlist seeds prioritise *attention* (judgment's use), they do **not** bound the funnel's enumeration. Every exact-token-in-class-live record crosses the firewall whether or not its owner was pre-listed; the watchlist is provably incomplete, so it never decides what the funnel enumerates. Skip only if there is no incumbent alert AND the frozen plan carries no entries on this axis — the plan is the search authority. **The plan carries no owner lane from the manifest's watchlist.** Read owners from the records this axis and the primary sweep returned. Propose an owner slice only where an owner's other marks could change the assessment, for example when the records show a family of marks sharing the element. A bare-owner count is never written up as a reviewed portfolio or as "portfolio too large, noted". Read an owner's portfolio as far as it answers a question about this owner: can it block, would it, and what kind of filer it is. Never its whole register because it is an incumbent.
 

package/driver/skills/clearance-search/firm-wide-reasoning.md

@@ -229,12 +229,13 @@ sensitivity, or a commercial partnership cannot lift a finding past what the fra
 they only change *whether they'd win* or the *character* of the dispute, and the framework then produces
 the band.
 
-### Enforcer profiling — mandatory for findings above the lowest band
+### Enforcer profiling — mandatory for findings rated medium risk or higher
 
 Assess: Is this a portfolio brand? TTAB/UDRP history? Institutional vs individual filer? "No large brands
 or assertive enforcers" is a practical factor the staff lawyer weights heavily. *(`courtlistener__search` covers US
 federal courts incl. CAFC trademark-appeal opinions — NOT raw TTAB proceedings. For TTAB direct
-(oppositions, cancellations, ex parte), source is TTABVUE — separate integration, not yet wired.)*
+(oppositions, cancellations, ex parte), source is TTABVUE — separate integration, not yet wired.)* The Step 3.5 query (`phase2-execution.md`) asks for
+the owner's enforcement record; what it finds is a lead, cited inline, never a verified authority.
 
 Profiling informs the **business / practical read only — it never raises the legal read** (the read is the
 confusion comparison; see *The consumer confusion test*). When the signals cut both ways — a broad