clearotron 0.4.0-beta.0 → 0.4.0-beta.2

package/driver/common-law-receipts.mjs

@@ -30,6 +30,7 @@ export const MIN_CELLS_PER_VARIANT = 7;
 // It composes `queryKey`, which is the one author of what "the same text" means across a provider
 // boundary, and keeps its own wrapping-quote strip because a term arrives quoted here and does not there.
 import { queryKey } from "./connotation-search.mjs";
+import { dictatedCells } from "../providers/perplexity/src/core.js";   // what the spec asks, product or blocks
 
 const norm = (s) => queryKey(String(s || "").trim().replace(/^["'`\u2018\u2019\u201c\u201d]+|["'`\u2018\u2019\u201c\u201d]+$/g, ""));
 
@@ -285,6 +286,30 @@ export function findGridLedgerViolations(manifestOrTerms, ledgerRaw, { minCellsP
   return shortVariants(variants, (term) => platforms.get(norm(term))?.size || 0, minCellsPerVariant);
 }
 
+/**
+ * — THE RECEIPTS JOIN FOR A GRID IN BLOCKS: every cell the spec dictated ran — a cell or a recorded gap in
+ * the ledger — judged cell by cell. The count and identity joins below assume every term owes every
+ * platform, which a grid the matter frame decided does not ask. Same {variant, cells, expected} shape as
+ * findGridLedgerViolations, plus the platforms still owed, so the `grid_join_missing` token is unchanged.
+ * Throws on an unparseable ledger.
+ *
+ * @returns {Array<{variant:string, cells:number, expected:number, missing:string[]}>}
+ */
+export function findUnranDictatedCells(spec, ledgerRaw) {
+  const map = parseGridLedger(ledgerRaw);
+  const owed = new Map();   // term → [platform, ran?]
+  for (const [term, platform] of dictatedCells(spec)) {
+    if (!owed.has(term)) owed.set(term, []);
+    owed.get(term).push([platform, map.get(norm(term))?.has(norm(platform)) === true]);
+  }
+  const out = [];
+  for (const [variant, rows] of owed) {
+    const missing = rows.filter(([, ran]) => !ran).map(([p]) => p);
+    if (missing.length) out.push({ variant, cells: rows.length - missing.length, expected: rows.length, missing });
+  }
+  return out;
+}
+
 // ── WS-B: platform-identity join (per-customer profiles) ────────────────────────────────────────────────
 // The count floor proves HOW MANY distinct platforms each variant accounted for — never WHICH. With a
 // dictated per-customer platform list, a worker on gaming habit could sweep the wrong marketplaces and
@@ -674,6 +699,10 @@ export function splitGridSpec(spec, { outputPaths = {}, dispositionsPaths = {} }
       // The meaning seat sweeps no cells. `terms: []` is what makes its dispatch the meaning work and
       // nothing else, and it is why the grid halves keep an untouched 50/50 parity split.
       terms: isMeaning ? [] : terms[h],
+      // A grid in blocks keeps its blocks, each cut to this half's terms (a term owns all its cells in one half).
+      ...(Array.isArray(spec.grids) ? { grids: spec.grids.map((g) => ({ terms: g.terms.filter((t) => !isMeaning && terms[h].includes(t)), platforms: g.platforms })).filter((g) => g.terms.length) } : {}),
+      // The famous-mark record names only the cells this seat runs.
+      ...(Array.isArray(spec.famous) ? { famous: spec.famous.filter((t) => !isMeaning && terms[h].includes(t)) } : {}),
       output_path: outputPaths[h] ?? spec.output_path,
       // The disposition_required stamp still rides BOTH halves: it is the receipt-presence arm, and a
       // stray pr_risk block in the non-owning half must still be judged rather than waved through.
@@ -714,7 +743,8 @@ export function splitGridSpec(spec, { outputPaths = {}, dispositionsPaths = {} }
  *     batch has since closed is dropped). This is the never-thinner guarantee: every dictated cell is
  *     accounted as a real cell or an HONEST gap, so a half failure can never yield a ledger that is
  *     thinner but still valid. A half's honestly-recorded gap for a cell OUTSIDE the spec (a re-keyed
- *     variant / an extra swept platform) is UNIONED in too — the spec-only recompute would erase it.
+ *     variant / an extra swept platform) is UNIONED in too — the spec-only recompute would erase it,
+ *     except a meaning query's gap row when the merged receipts answer that query.
  *   - extras.pr_risk[]: concatenated (a then b), deduped by trimmed query — restores the full dictated
  *     meaning-receipt set from the per-half partitions. Other extras keys: arrays concatenate,
  *     anything else first-defined wins.
@@ -773,23 +803,32 @@ export function mergeGrids(a, b, { spec, halfErrors = {} } = {}) {
   // gaps: recomputed against the FULL spec
   const halfTerms = splitGridTerms(spec?.terms ?? []);
   const gaps = [];
-  for (const term of spec?.terms ?? []) {
-    for (const platform of spec?.platforms ?? []) {
-      if (seen.has(key(term, platform))) continue;
-      const owner = halfOfTerm(halfTerms, term);
-      const error = gapErr.get(key(term, platform))?.error
-        || (owner && halfErrors[owner]) || "cell not accounted by either half-grid";
-      gaps.push({ term, platform, error });
-    }
+  // Over the cells the spec DICTATES, never terms × platforms: a grid the frame decided is blocks, and the
+  // product of its unions would make a gap of every cell nobody asked for, which the closure pass would run.
+  for (const [term, platform] of spec ? dictatedCells(spec) : []) {
+    if (seen.has(key(term, platform))) continue;
+    const owner = halfOfTerm(halfTerms, term);
+    const error = gapErr.get(key(term, platform))?.error
+      || (owner && halfErrors[owner]) || "cell not accounted by either half-grid";
+    gaps.push({ term, platform, error });
   }
   // UNION honestly-recorded NON-SPEC gap rows: a half may record a gap for a cell OUTSIDE the canonical
   // spec (a legitimately re-keyed variant / an extra platform a half swept). The spec-only recompute above
   // never emits those, silently erasing an honestly-recorded coverage gap — union them so an honest gap
   // survives the merge. A cell present in cells[] still wins (a stale gap a supplementary batch has since
   // closed is dropped exactly as for spec cells), and a gap already emitted by the spec loop is not doubled.
+  //
+  // A MEANING QUERY THE MERGED RECEIPTS ANSWER KEEPS NO GAP ROW. The grid tool records one for each dictated
+  // query its program did not return, and the engine's re-issue can answer that query later in the same
+  // ledger. Kept beside the answer, the row says a search did not complete when it did, and the closure pass
+  // takes every gap row for a store cell, so it searches the query again on a site called "connotation".
+  // Queries are matched as the receipts are (norm).
+  const answered = new Set((Array.isArray(extras.pr_risk) ? extras.pr_risk : [])
+    .map((e) => (typeof e?.query === "string" ? norm(e.query) : "")).filter(Boolean));
   const gappedKeys = new Set(gaps.map((g) => key(g.term, g.platform)));
   for (const [k, g] of gapErr) {
     if (seen.has(k) || gappedKeys.has(k)) continue;
+    if (String(g.platform).toLowerCase() === "connotation" && answered.has(norm(g.term))) continue;
     gaps.push({ term: g.term, platform: g.platform, error: g.error || "cell not accounted by either half-grid" });
   }
   return { cells, extras, gaps };
@@ -861,9 +900,9 @@ export function mergeCommonLawFindings(parts) {
 // a present row chose.
 //
 // The join bug is fixed independently, because a census nobody can trust is worse than none:
-//   • TERM match is EXACT after stripping a trailing annotation ("提基冰沙 (ZH: …)"). It used to be
+//   • TERM match is EXACT after stripping a trailing annotation ("瓦波冰沙 (ZH: …)"). It used to be
 //     `rowTerm.includes(cellTerm)`, so the row for "CORAL FREEZE" was credited to the cells for "SLUSH"
-//     and even "TIK", and the row for "提基冰沙" to the cell for "冰沙" — 71 of the 221.
+//     and even "WAV", and the row for "瓦波冰沙" to the cell for "冰沙" — 71 of the 221.
 //   • a platform ROLL-UP row ("Multiple platforms") counts only when the term has no platform-specific
 //     row of its own; combined with the substring bug it used to match every platform at once.
 // `undisposed` (title containment over raw web-search titles) is GONE: it returned 1,986 rows on the
@@ -926,7 +965,16 @@ export function findSimilarListingSignals(findingsContent) {
   const signals = [];
   const OWNER_RE = /(?:developer|publisher|seller|owner)(?:\s+|_)of(?:\s+|_)record\W{0,5}([^\n|]+)/i;
   const OWNER_SKIP_RE = /not extracted|unknown|n\/a|none|^[\s—–-]*$/i;
+  // A table whose header lists the of-record fields matches OWNER_RE on its first label and captures the
+  // next one, so a label reached the register as an owner's name ("publisherofrecord", once its
+  // underscores were stripped). A label is never a name.
+  const OWNER_LABEL_RE = /^(?:developer|publisher|seller|owner)[\s_]*of[\s_]*record\b/i;
   const URL_RE = /https?:\/\/[^\s)|\]">]+/;
+  // A TABLE'S HEADER ROW NAMES COLUMNS, NEVER AN OWNER, whatever column follows an of-record label ("URL",
+  // "Store"). It is the row a separator row follows, and both are table rows: a bare "---" under an owner's
+  // line is a rule, not a separator, and the owner stands.
+  const SEPARATOR_RE = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+  const headerRow = (ln, next) => ln.includes("|") && String(next ?? "").includes("|") && SEPARATOR_RE.test(next);
   let inMatrix = false, inFindings = false;
   let block = null;   // { markText, owner, url }
   const flush = () => {
@@ -935,7 +983,9 @@ export function findSimilarListingSignals(findingsContent) {
     }
     block = null;
   };
-  for (const ln of (findingsContent || "").split("\n")) {
+  const lines = (findingsContent || "").split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const ln = lines[i];
     const h = ln.match(/^(#{1,6})\s+(.*)/);
     if (h) {
       const title = h[2];
@@ -958,10 +1008,10 @@ export function findSimilarListingSignals(findingsContent) {
       continue;
     }
     if (inFindings && block) {
-      const om = ln.match(OWNER_RE);
+      const om = headerRow(ln, lines[i + 1]) ? null : ln.match(OWNER_RE);
       if (om && !block.owner) {
         const owner = om[1].replace(/[*_`]/g, "").trim();
-        if (owner && !OWNER_SKIP_RE.test(owner)) block.owner = owner.slice(0, 120);
+        if (owner && !OWNER_SKIP_RE.test(owner) && !OWNER_LABEL_RE.test(om[1].trim())) block.owner = owner.slice(0, 120);
       }
       const um = ln.match(URL_RE);
       if (um && !block.url) block.url = um[0];

package/driver/commonlaw-carry.mjs

@@ -9,7 +9,7 @@
 //
 // ── the loss this exists to catch ────────────────────────────────────────────────────────────────────
 //
-// TIKI TWIST and TIKI TROPICS. Both sat in R3's own common-law records and reached no findings list, and
+// WAVO TWIST and WAVO TROPICS. Both sat in R3's own common-law records and reached no findings list, and
 // nothing anywhere said why. `common-law-receipts.mjs`'s `findGridCandidateOmissions` already reports one
 // class of this — a hit cell denied by the Negative-results matrix — but it is CELL-granular, and a cell
 // carries up to eight candidates. This is the per-candidate half.
@@ -39,7 +39,7 @@
 // ── THE NON-LATIN TRAP IS ANSWERED, NOT AVOIDED ──────────────────────────────────────────────────────
 //
 // `normalizeJoinText` folds every non-[A-Za-z0-9] run to a space, so it returns the EMPTY STRING for
-// 色度, 冰沙, 提基冰沙, ティキスラッシュ and 티키 슬러시. A mark-keyed trace is structurally blind to
+// 澜珀, 冰沙, 瓦波冰沙, ワボスラッシュ and 와보 슬러시. A mark-keyed trace is structurally blind to
 // every one of them.
 //
 // NOTHING HERE TOUCHES IT. A Han-script candidate joins on its ASCII/percent-encoded URL. A Han-script

package/driver/compare.mjs

@@ -11,7 +11,7 @@
 
 import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { join, basename, isAbsolute } from "node:path";
-import { driverDir } from "../shared/driver-dir.mjs";   //
+import { driverDir, driverFileName } from "../shared/driver-dir.mjs";   //
 import { fileURLToPath } from "node:url";
 import { STAGES, paths } from "./stages.mjs";
 import { isEntrypoint } from "../shared/is-entrypoint.mjs";   // — one entry-point test, all spellings
@@ -141,7 +141,7 @@ function outPath(dir, stage, axis) {
 // last JSONL line of a stage's telemetry, tried at <dir>/<label>.jsonl (snapshot) and <dir>/_driver/<label>.jsonl.
 function readTel(dir, stage, axis) {
   const label = labelFor(stage, axis);
-  for (const p of [join(dir, `${label}.jsonl`), driverDir(dir, `${label}.jsonl`)]) {
+  for (const p of [join(dir, driverFileName(`${label}.jsonl`)), driverDir(dir, `${label}.jsonl`)]) {
     try {
       const lines = readFileSync(p, "utf8").trim().split("\n").filter(Boolean);
       if (lines.length) return JSON.parse(lines[lines.length - 1]);

package/driver/connotation-search.mjs

@@ -4,16 +4,16 @@
 // searched-not-asserted enforcement (validator side). Sister of use-check.mjs (spec 11): a "clean" claim
 // is sayable ONLY when a search produced it.
 //
-// The bug this closes (live incident: a mark reading as a benign given name one letter off the Sureño
+// The bug this closes (live incident: a mark reading as a benign given name one letter off the Mara
 // street-gang label): the deterministic grid runs term×platform marketplace cells only — it asks
 // "who SELLS this name?", never "what does this name MEAN?". A marketplace grid that finds no listing for
 // the mark is SILENT on the street-gang association; only a MEANING search surfaces it. With no machine slot
 // for the meaning search, the model fabricated "(None identified — affirmative sweep) … no gang associations".
 //
 // Two halves, both PURE (no node imports → tests offline):
-//   1. buildConnotationQueries — the driver dictates the meaning queries (mark + near-forms × shapes) VERBATIM
-//      into grid-spec.json; the perplexity plugin runs them on the general web and records each into the grid
-//      ledger's extras.pr_risk[] (a recorded query — even with empty results — is the receipt the search ran).
+//   1. meaningAnglesFromMatterContext — the driver dictates the meaning queries, the matter frame's own list,
+//      VERBATIM into grid-spec.json; the perplexity plugin runs them on the general web and records each into the
+//      grid ledger's extras.pr_risk[] (a recorded query — even with empty results — is the receipt the search ran).
 //   2. findConnotationViolations — the validator: recorded meaning receipts must be disposed of, per query,
 //      citing the receipt. A PR/reputational section that ASSERTS a clean result must additionally cite a
 //      Connotation-search source line. A searched-clean (recorded queries, empty results) passes.
@@ -28,98 +28,21 @@
 // section at all matched no block, so DELETING the section passed the gate. Receipts present now means
 // receipts validated, whatever the document says.
 
-// The meaning query shapes. NOT a banned-word list — these are SEARCH directions ("what does this name mean,
-// and to whom?"). Perplexity surfaces foreign-language / gang / slang meanings from English query shapes
-// (a benign given name one letter off "Sureño" → the gang label surfaces from "<mark> gang" / "<mark> urban dictionary").
-
+// THE SHAPES THE FIXED MEANING SWEEP ASKED, until 2026-09-25: every run searched the first 6 spellings on
+// the five core shapes and the first 8 translated forms on the three below, about 54 web questions whatever
+// the matter. The matter frame decides the sweep now, as it decides the stores, and no query is built from
+// these. They stay so connotationReasonKey still reads the queries of the runs archived before.
 export const CONNOTATION_SHAPES = ["meaning slang", "gang", "offensive", "urban dictionary", "wikipedia"];
-
-/**
- * Build the dictated connotation queries from the mark + its near-forms (the grid variants). De-dups
- * case-insensitively and caps the term count (the meaning search is the mark + a handful of near-forms, not
- * the full variant explosion). Returns ["<term> <shape>", …] — run VERBATIM by the plugin's grid program. PURE.
- */
-export function pickConnotationTerms(terms, maxTerms = 6) {
-  const seen = new Set();
-  const picked = [];
-  for (const t of (terms ?? [])) {
-    const v = String(t ?? "").trim();
-    if (!v) continue;
-    // KEYED THE SAME WAY THE GATES COMPARE. A producer that folds less than its consumer dictates two
-    // terms the gate can only see as one, and a seat recording either satisfies it for both — the gate
-    // then passes a query that never ran, which is the fault it exists to catch, inverted.
-    const k = queryKey(v);
-    if (seen.has(k)) continue;
-    seen.add(k);
-    picked.push(v);
-    if (picked.length >= maxTerms) break;
-  }
-  return picked;
-}
-
-export function buildConnotationQueries(terms, { shapes = CONNOTATION_SHAPES, maxTerms = 6 } = {}) {
-  const picked = pickConnotationTerms(terms, maxTerms);
-  const queries = [];
-  for (const t of picked) for (const s of shapes) queries.push(`${t} ${s}`);
-  return queries;
-}
-
-// WP-56 B1 — the NON-ENGLISH half of the meaning sweep. The core bucket runs the mark + its first
-// near-forms; the manifest's translated/transliterated forms (non-Latin script rows, "丝绸与铁 / 席尔克"
-// packed alternates) sat beyond its cap, so a mark could ship with no meaning read in the very scripts the
-// manifest committed to search. These forms get their OWN capped bucket with meaning-appropriate shapes —
-// the slang / urban-dictionary shapes are Latin-web search directions; a non-Latin or translated form
-// wants its meaning and English reading. Which forms exist stays the variants stage's judgment (the
-// structured manifest); this stays mechanical.
 export const CONNOTATION_SHAPES_TRANSLIT = ["meaning", "meaning in english", "offensive meaning"];
 
-// A letter outside the Latin script (property escape, not a codepoint range — punctuation/dashes in a
-// Latin term must not read as "non-Latin").
-const NON_LATIN_LETTER_RE = /(?![\p{Script=Latin}])\p{L}/u;
-
-/**
- * Build the translit/translation connotation queries from the STRUCTURED variant-manifest model's
- * variants[] ({value, category, rationale}): rows typed category "transliteration" (a Latin-script
- * translation typed there rides along) plus any variant value carrying a non-Latin letter, whatever its
- * category. " / "-packed alternates split into individual forms; forms the core bucket already queries
- * (coreTerms, case-insensitive) are dropped; own cap (default 8, beside the core bucket's 6).
- * Returns ["<form> <shape>", …] like buildConnotationQueries. PURE.
- */
-export function buildTranslitConnotationQueries(modelVariants, { shapes = CONNOTATION_SHAPES_TRANSLIT, maxTerms = 8, coreTerms = [] } = {}) {
-  const seen = new Set((coreTerms ?? []).map((t) => queryKey(t)).filter(Boolean));
-  const picked = [];
-  for (const v of (modelVariants ?? [])) {
-    const value = String(v?.value ?? "").trim();
-    if (!value) continue;
-    const isTranslit = String(v?.category ?? "").trim().toLowerCase() === "transliteration" || NON_LATIN_LETTER_RE.test(value);
-    if (!isTranslit) continue;
-    for (const form of value.split(" / ")) {
-      const f = form.trim();
-      if (!f) continue;
-      const k = queryKey(f);
-      if (seen.has(k)) continue;
-      seen.add(k);
-      picked.push(f);
-      if (picked.length >= maxTerms) break;
-    }
-    if (picked.length >= maxTerms) break;
-  }
-  const queries = [];
-  for (const t of picked) for (const s of shapes) queries.push(`${t} ${s}`);
-  return queries;
-}
-
-// ── P2-C (Round-2 §8b) — the DERIVED half of the sweep's scope ─────────────────────────────────────────
-// The fixed CONNOTATION_SHAPES floor asks generic search DIRECTIONS ("<mark> offensive") and stays — it is
-// not a sensitivities checklist, and on the evidence run it did retrieve the cultural-criticism material.
-// What no fixed list can ask is the PER-MATTER angle: the cultural origin a word evokes, the charged history
-// of its imagery, the controversy specific to these goods in this market. Deriving those is judgment, so the
-// MATTER FRAME authors them — its dictated `Meaning angles:` line (semantic field × market/industry; the
-// stage message dictates it and the matterContext validator requires it on fresh runs, `none` allowed as an
-// explicit reasoned emptiness). This parser is the mechanical half: extract, sanitize, cap. The queries are
-// appended VERBATIM to grid-spec connotation.queries BESIDE the floor, so the per-query identity join
-// (findDroppedConnotationQueries) polices their execution exactly like the floor's. NEVER a hardcoded
-// sensitivities checklist — the angles are authored per matter; code only carries them.
+// ── THE MATTER FRAME'S LIST IS THE WHOLE MEANING SWEEP (ruled 2026-09-25) ─────────────────────────────────
+// Deriving what a name could mean, and to whom, is judgment, so the MATTER FRAME authors the questions: its
+// `Meaning angles:` line — the mark's semantic field × this matter's market and goods, the languages whose
+// buyers matter, and any slang, gang or offensive reading (the stage message dictates it and the
+// matterContext validator requires it on fresh runs, `none` allowed as an asserted zero). A fixed floor rode
+// beside it and is gone. This parser is the mechanical half: extract and sanitize; the frame decides how
+// many. The queries go VERBATIM into grid-spec connotation.queries, and the per-query identity join
+// (findDroppedConnotationQueries) polices their execution. NEVER a hardcoded sensitivities checklist.
 
 // The frame's machine line (mirrors channelsFromMatterContext's "Search channels:" shape), ANCHORED to a
 // line start: prose that merely MENTIONS `"Meaning angles:" line …` must never read as the line (the
@@ -167,15 +90,15 @@ function sanitizeMeaningAngle(raw) {
 }
 
 /**
- * Parse the matter frame's `Meaning angles: <q>; <q>; …` line into sanitized derived queries.
- * Semicolon-separated (an angle phrase may contain commas); `none` (the explicit reasoned-emptiness form)
- * and a missing line both yield [] — the floor always rides regardless. Sanitization is mechanical only:
- * strip WRAPPING quotes/backticks (see sanitizeMeaningAngle — a phrase quote inside the angle survives),
- * collapse whitespace, drop empties and over-length entries, dedupe
- * case-insensitively (against itself and `alreadyQueried`, so a derived angle never double-dictates a floor
- * query), cap the count. Content judgment stays the frame's. PURE.
+ * Parse the matter frame's `Meaning angles: <q>; <q>; …` line into the sanitized meaning queries.
+ * Semicolon-separated (an angle phrase may contain commas); `none` (the asserted-zero form) and a missing
+ * line both yield [], and meaningAnglesAssertedNone tells the two apart: only the first is the frame's
+ * decision. Sanitization is mechanical only: strip WRAPPING quotes/backticks (see sanitizeMeaningAngle — a
+ * phrase quote inside the angle survives), collapse whitespace, drop empties, dedupe case-insensitively
+ * (against itself and `alreadyQueried`). No cap on length or count: the frame's tool refuses an over-long
+ * question at the source, every question is run as written, and how many is the frame's call. PURE.
  */
-export function meaningAnglesFromMatterContext(md, { alreadyQueried = [], maxAngles = 8, maxLen = 90 } = {}) {
+export function meaningAnglesFromMatterContext(md, { alreadyQueried = [], maxAngles = Infinity } = {}) {
   const m = String(md || "").match(MEANING_ANGLES_RE);
   if (!m) return [];
   const value = m[1].trim();
@@ -188,7 +111,7 @@ export function meaningAnglesFromMatterContext(md, { alreadyQueried = [], maxAng
     // quote runs at both ends unconditionally, so `"` sanitized to "" and fell out here; the wrapper rule
     // keeps it, and a lone `"` dictated as a query is a search nobody asked for that no receipt can ever
     // match — the failure this change exists to stop. Dropped explicitly rather than as a side effect.
-    if (!q || !/[\p{L}\p{N}]/u.test(q) || q.length > maxLen) continue;
+    if (!q || !/[\p{L}\p{N}]/u.test(q)) continue;
     const k = queryKey(q);
     if (seen.has(k)) continue;
     seen.add(k);
@@ -198,6 +121,12 @@ export function meaningAnglesFromMatterContext(md, { alreadyQueried = [], maxAng
   return picked;
 }
 
+/** Whether the matter frame asserted that no meaning question applies: its `Meaning angles:` line reads `none`. PURE. */
+export function meaningAnglesAssertedNone(md) {
+  const m = String(md || "").match(MEANING_ANGLES_RE);
+  return Boolean(m) && /^none\b/i.test(m[1].trim());
+}
+
 // The PR / reputational / connotation section heading (the only place the gate polices — it must not flag a
 // clean note that appears in some other section's prose, mirroring use-check's section-scoping).
 const SECTION_RE = /reputational|connotation/i;
@@ -1125,7 +1054,7 @@ const RECURRENT_MIN = 4;
 // ── — THE REASON SCALE IS MEASURED HERE AND DELIBERATELY DOES NOT DECIDE ────────────────────────
 // was ruled "recurrence counts independent reasons, not query strings": a dictated query is
 // "<term> <shape>", the sweep asks every shape of every mark variant, so the seven queries reading
-// BIODELFIN/BIODELFINO/BIODOLPHIN/ΒΙΟΔΕΛΦΙΣ/ΔΕΛΦΙΣ/ΜΠΙΟΔΕΛΦΙΣ/Дельфис + "offensive meaning" that all
+// BIOVELTRYN/BIOVELTRINO/BIOVELTRINE/ΒΙΟΒΕΛΤΡΙΝ/ΒΕΛΤΡΙΝ/ΜΠΙΟΒΕΛΤΡΙΝ/Вельтрин + "offensive meaning" that all
 // return the dictionary definition of the word "offensive" are one reason asked seven ways. That
 // reasoning is sound and the shape is the right way to express it. It is implemented below as
 // connotationReasonKey, and it is RECORDED on every run — but it is NOT what clears the floor.
@@ -1133,7 +1062,7 @@ const RECURRENT_MIN = 4;
 // IT WAS BUILT, MEASURED AGAINST THE THREE PRESERVED RUNS, AND REFUTED BY THEM. Making the floor read
 // the reason scale inverts the signal it exists to read:
 //   - The 2026-07 evidence run (test/fixtures/coral-freeze-pr-risk.json, 54 recorded queries): the floor's
-//     obligation set goes 7 → 0. `punchdrink.com/articles/problem-with-tiki-bars-cultural-appropriation`
+//     obligation set goes 7 → 0. `punchdrink.com/articles/problem-with-wavo-bars-cultural-appropriation`
 //     — THE receipt this floor was invented to force onto the page — is surfaced by four queries that are
 //     all shape "offensive", so it scores ONE reason and drops out. The gate stops firing on the run it
 //     was designed for.

package/driver/contract-arm2-baseline.json

@@ -11,7 +11,7 @@
     "the baseline tracks named elements, and a rename is a new name. Regenerate rather than work around it.",
     "Measured 139 of 287 declared elements."
   ],
-  "total": 104,
+  "total": 105,
   "byStage": {
     "matter-frame": [
       "### Intake asks line shape — rendered by the driver from intake_asks[]",
@@ -22,14 +22,15 @@
       "Class scope & adjacency — classes scoped IN with a one-line reason each, classes deliberately scoped OUT",
       "Return shape — hand the frame back through record_matter_frame, write NO file, return ONLY a 2-3 line summary",
       "Scope reasoning — search-wide/cite-narrow, the in-scope-by-reach routes, and the reopen trigger behind each exclusion",
-      "search_channels — the domains where real use of THIS matter's goods would show"
+      "confusable_forms — the forms a buyer could confuse, searched on the stores",
+      "search_channels — the domains where real use of THIS matter's goods would show",
+      "set_aside — the profile stores and forms the frame does not search, each with its reason"
     ],
     "clearance-variants": [
       "### Scope ledger rows — {Layer, Item, Status: applied|dropped, Reason, Reopen trigger} across variant / field / source / jurisdiction",
       "Archetype — primary (one of six) + modifiers + one-line reasoning",
       "Cross-mark themes — shared elements, shared conceptual themes, shared industry-incumbent alerts (multi-mark requests)",
       "Distinctiveness & registrability read — spectrum placement per market language, descriptive/generic/laudatory/geographic/deceptive/offensive flags, acquired-distinctiveness note",
-      "Famous-mark flags per element + famous_mark_calls_needed[]",
       "Formative root: <root> — the shortest distinctive stem a family of marks would share, on its own line",
       "Output paths + return shape — write the prose manifest and the structured model to the named absolute paths, return ONLY the path + a 2-3 line summary",
       "Per-jurisdiction sub-queries",
@@ -41,6 +42,7 @@
       "Verify? ✅ column on every transliteration row of the prose Variants table",
       "Watchlist union / client-exclusion / 24-owner cap applied by the model before emitting watchlist_owners[]",
       "elements[] — {value, kind: distinctive|common|saturated-common}",
+      "elements[].famous_mark_flag — the elements Step 2's famous-mark check flags",
       "incumbent_classes[] — the industry-incumbent alert's Nice classes",
       "variants[].category — one of core|phonetic|visual|transliteration|numeric|composite|other",
       "variants[].rationale — one line per variant",
@@ -73,13 +75,12 @@
     "register-unit": [
       "`CROSS-CHECK REQUIRED: <what> — <why>` — the check that is needed and why",
       "`CROSS-CHECK REQUIRED:` exact line shape — prefix, em-dash, mark in CAPS, own line",
-      "escalation judgement — the CROWD BOUND: attempt each dangerous-category slice once class-scoped, gate on the RESULT, stop terminal on a crowd, and write a block only for the distinctive anchor",
+      "escalation judgement — the CROWD BOUND: attempt each dangerous-category slice once class-scoped, gate on the RESULT, decide on a crowd, and write a block only for the distinctive anchor",
       "final return — the absolute output path plus queries-enumerated count, incomplete-block count, records carried forward",
       "proposal `romanization` beside a single non-Latin term — plain-ASCII Latin form, space-separated syllables",
       "proposal class scoping — pass nice_classes:[...] AND in_scope_classes:[...] on every proposal/call",
       "proposal envelope — predicate enum {exact, default, wildcard, phonetic, owner}, term vs terms, rationale",
       "reading the band back and judging it — keep proposing until the axis's dangerous named band is covered",
-      "recall carry-or-justify — for each prior-confirmed conflict, a reasoned drop row written over the fetched record (primary-sweep only)",
       "supplemental proposals — WHICH queries the manifest/frame warrant beyond the dictated set",
       "the dictated entry list — qid, predicate, terms, owner, nice_classes, regions, when-guard, expected_kind, covered_by"
     ],