clearotron 0.2.0 → 0.2.1

package/driver/publish/seed-pool.mjs

@@ -105,12 +105,20 @@ export function frozenSamples(examplesDir) {
  */
 export async function seedPool({ pool, examplesDir, republish }) {
   const existing = poolRunIds(pool);
-  if (existing.length) {
-    // Named with the count, not just refused. "It did not seed" and "it did not seed BECAUSE there are
-    // already 14 runs here" are the same non-event to the code and different facts to a reader.
-    return { seeded: [], skipped: `the pool already holds ${existing.length} run(s)`, problems: [] };
-  }
-
+  // ── A POOL THAT ALREADY HOLDS SOMETHING IS TOPPED UP, NOT SKIPPED (tracker issue 277) ──────────────
+  //
+  // This used to return early on any non-empty pool. That was invisible while `demo/` shipped one child:
+  // seeding one and seeding all were the same act. When the other three landed, every box seeded before
+  // that day kept its single demo through every upgrade, because the pool was no longer empty and this
+  // returned without looking at what the package now carried.
+  //
+  // DEMOS ARE PACKAGE CONTENT, NOT USER DATA, so the package's set is the one that should be there. What
+  // is already published is left exactly as it is — this adds what is missing and removes nothing, so a
+  // pool holding a run this package does not ship keeps it.
+  //
+  // AND IT IS ONLY EVER A DEMO POOL. `bin/start.mjs` calls this inside its `--demo` branch alone; a real
+  // install is told its archive is empty and pointed at the demo command. Nothing here can put an example
+  // into a pool holding a customer's work, and that gate is the reason this can top up safely at all.
   const { samples, problems } = frozenSamples(examplesDir);
   if (!samples.length) {
     // The empty archive is now the SYMPTOM of something, and this is where the something is named.
@@ -118,11 +126,13 @@ export async function seedPool({ pool, examplesDir, republish }) {
   }
 
   const seeded = [];
+  const already = [];
   const failures = [];
   for (const s of samples) {
-    // Belt and braces against a partial pool: the emptiness check above already means nothing is here,
-    // but a sample list carrying the same runId twice would otherwise overwrite silently.
+    // A sample list carrying the same runId twice would otherwise overwrite silently.
     if (seeded.includes(s.meta.runId)) { failures.push(`${s.name}: runId ${s.meta.runId} appears twice under ${examplesDir}`); continue; }
+    // Already published: left alone, and NAMED. Silence here is what the old early return produced.
+    if (existing.includes(s.meta.runId)) { already.push(s.meta.runId); continue; }
     try {
       // poolUrl "" for the same reason the demo passes it: the report's link block addresses a
       // deployment that serves the pool at a public URL, and this one is served from this machine.
@@ -133,5 +143,10 @@ export async function seedPool({ pool, examplesDir, republish }) {
       failures.push(`${s.name}: ${String(e?.message ?? e)}`);
     }
   }
-  return { seeded, skipped: null, problems: [...problems, ...failures] };
+  // `skipped` still carries a sentence when there was nothing to add, because "seeded 0" and "seeded 0
+  // BECAUSE all four were already here" are the same number and different facts.
+  const skipped = !seeded.length && already.length
+    ? `the pool already holds all ${already.length} example(s) this package ships`
+    : null;
+  return { seeded, already, skipped, problems: [...problems, ...failures] };
 }

package/driver/record-carry.mjs

@@ -825,3 +825,142 @@ export function silentlyLostFindings({ reconciliation = null, carryRows = null,
     population_empty: false, cross_checked: crossChecked,
     checked: ended.length, matched: seen.length, lost };
 }
+
+/**
+ * Positions the DIGEST ended as findings that did not reach the findings, dropped WITH a stated reason.
+ *
+ * ── THE SIBLING'S BLIND SPOT, AND IT IS THE ONE THAT REACHED A CLIENT (tracker issue 248) ──────────
+ *
+ * `silentlyLostFindings` above is correct and must not be widened to cover this. Its population is
+ * `step-silent` — a finding-ending followed by silence — and its own header records why that boundary
+ * exists: silent drops are the norm (690 of 741 records on the evidence run), so a rule flagging them
+ * broadly would flag almost everything, and the defect it targets is the CONJUNCTION of silence after a
+ * finding-ending.
+ *
+ * It also anticipated this gap in writing: "nine divergences from a digest finding-ending, every one of
+ * them `step-stated`". Nine of the shape nothing checked.
+ *
+ * MEASURED ON R2 `russet-kestrel`, delivered 2026-09-06. The sibling ran and reported
+ * `{checked:5, matched:5, lost:0}` — correctly. On that same delivery two marks from the lawyer's final
+ * list, `OSLER DELPHI` and `DELFITY`, one rated HIGH, are absent from `findings.json`. They were dropped
+ * WITH a reason, so they sat outside the sibling's population by design:
+ *
+ *   IMMATERIAL ask:recall:recall-osler-delphi: … — OSLER DELPHI / Osler Diagnostics Limited is
+ *   already reasoned on the incumbent sheet in register-findings.md.
+ *
+ * WHY THE STATED CASE IS THE MORE DANGEROUS ONE. A silent drop leaves a hole. A stated drop leaves a
+ * SENTENCE, and the sentence reads as diligence. On that one delivery `doubt-closure.md` carries 92
+ * recall asks and 66 rulings of IMMATERIAL. A drop with a reason nobody verifies is not accounted for;
+ * it is unexamined with a paper trail.
+ *
+ * `step-structural` is deliberately NOT in this population: it is a mechanical screen verdict
+ * (`the in-line record screen returned "…"`), not a judgment sentence a reader would take on trust.
+ * `absent` belongs to the sibling's family, not this one.
+ *
+ * WHAT THIS DOES NOT DECIDE. Whether any given stated reason is RIGHT. That is a change to what the
+ * client receives and is the owner's call; this makes the class visible, which is worth having whichever
+ * way that lands, because today nobody would know the closures happened.
+ *
+ * Same contract as the sibling, deliberately: `computable:false` with a named reason rather than a clean
+ * `[]`; `population_empty` as its own state; `cross_checked` so a caller can tell "could not look" from
+ * "looked and found nothing"; and `matched` returned so a caller can insist the join actually joined —
+ * that field exists because a case-sensitive URI join once matched zero rows on every run and read as
+ * zero divergences. PURE.
+ */
+export function statedDivergenceFindings({ reconciliation = null, carryRows = null, digestFindingUris = null } = {}) {
+  const no = (reason, crossChecked = false) => ({ computable: false, reason, population_empty: false,
+    cross_checked: crossChecked, checked: 0, matched: 0, diverged: [] });
+  if (!reconciliation || reconciliation.computable !== true) {
+    return no("no computable recall-reconciliation — the digest's own endings are the population and there is none");
+  }
+  if (!Array.isArray(carryRows)) {
+    return no("no record-carry rows — the knockout lane writes none, so this join cannot look at that product");
+  }
+  // ── THE POPULATION IS THE CARRY ROWS, NOT THE RECONCILIATION (corrected 2026-09-07) ─────────────
+  //
+  // The first cut of this function gated on the reconciliation's finding-ended positions, mirroring the
+  // sibling. That inherited the sibling's BLIND SPOT along with its shape, and the check was inert on
+  // the very delivery it was written for. Replayed against R2 `russet-kestrel`:
+  //
+  //   silentlyLostFindings       checked=5 matched=5 lost=0
+  //   statedDivergenceFindings   checked=5 matched=5 diverged=0   ← should have named two marks
+  //
+  // The reconciliation names five finding-ended positions and they are five OTHER marks — DELPHIS
+  // bioenergetische Kosmetik, DELPHIC HSE, DELPHI, DELPHIN & EMERENCE, DELPHI DIAGNOSTICS. The two that
+  // were lost sit in the CARRY rows and the reconciliation never mentions them:
+  //
+  //   OSLER DELPHI  reach=placed stopped_at=digest reason_source=step-stated reason=digest:reasoned-negative
+  //   DELFITY       reach=placed stopped_at=digest reason_source=step-stated reason=digest:reasoned-negative
+  //
+  // The unit arms all passed because their fixtures put the mark in BOTH populations, which the real run
+  // does not. That is the lesson worth keeping: a fixture that satisfies two joins at once cannot tell
+  // you the joins disagree.
+  //
+  // So the carry rows are the population — they are where a stated drop is RECORDED — and the
+  // reconciliation is demoted to optional corroboration. Measured on that delivery, the correct
+  // population is 70 rows over 34 distinct marks, all `digest:reasoned-negative`, and it contains both.
+  const arrived = new Set(["finding", "findings-surface"]);
+  const population = carryRows.filter((r) => r?.uri
+    && r.reason_source === "step-stated"           // the sibling owns step-silent; step-structural is mechanical
+    && !arrived.has(r.reach));                     // arrived, or arrived somewhere visible, is not a divergence
+
+  // Kept for corroboration only. `ended` no longer gates anything; where the reconciliation DOES name a
+  // position it agrees with, that is recorded on the row so a reader can weigh it.
+  const ended = [];
+  for (const bucket of ["top_slice", "residual"]) {
+    for (const row of reconciliation[bucket] ?? []) {
+      if (row?.ending !== "finding") continue;
+      for (const uri of row.position_records ?? []) ended.push({ uri: lc(uri), mark: row.mark_text ?? null });
+    }
+  }
+  const endedUris = new Set(ended.map((e) => e.uri));
+  const byUri = new Map();
+  for (const r of carryRows) if (r?.uri) byUri.set(lc(r.uri), r);
+
+  // The disjoint-population guard, for the sibling's reason: overlap is the signal, a shortfall is not.
+  if (Array.isArray(digestFindingUris) && digestFindingUris.length && ended.length) {
+    const digest = new Set(digestFindingUris.map(lc));
+    if (!ended.some((e) => digest.has(e.uri))) {
+      return no(`the reconciliation's ${ended.length} finding-ended position(s) share NOTHING with the `
+        + `${digest.size} finding row(s) the digest's own typed calls recorded — the two populations are `
+        + "disjoint, so this join is examining a different set and its answer cannot be trusted", true);
+    }
+  }
+  // A ZERO POPULATION IS ITS OWN STATE. No stated drop recorded is a real answer on a healthy run, and
+  // it must not be reported in the same shape as "there were some and none diverged".
+  if (!population.length) {
+    return { computable: true, reason: "no record-carry row records a stated drop on this run — there is "
+      + "no population here, which is the healthy answer and not a comparison that found nothing",
+      population_empty: true, cross_checked: false, checked: 0, matched: 0, diverged: [] };
+  }
+
+  const diverged = [];
+  for (const row of population) {
+    const e = { uri: lc(row.uri), mark: row.mark ?? null };
+    // NAME THE ARTIFACT THE REASON POINTS AT. The defect this check exists for is an absence discharged
+    // by the WRONG artifact — "already reasoned in register-findings.md" answers a question nobody asked,
+    // because the ask was about the findings. Surfacing the cited artifact is what lets a reader see the
+    // substitution rather than read the sentence as diligence.
+    const reason = row.reason ?? null;
+    const cites = typeof reason === "string" ? (reason.match(/[a-z0-9._-]+\.(?:md|json)\b/gi) ?? []) : [];
+    diverged.push({ uri: e.uri, mark: e.mark ?? row.mark ?? null, reach: row.reach ?? null,
+      stopped_at: row.stopped_at ?? null, reason,
+      cites_artifact: cites.length ? [...new Set(cites.map(String))] : null,
+      // CORROBORATION, NOT A GATE. The reconciliation naming this position is worth a reader knowing;
+      // its SILENCE is not evidence of anything, which is exactly what the first cut got wrong.
+      reconciliation_agrees: endedUris.has(e.uri),
+      why: "this position was dropped with a stated reason and never reached the findings, and the reason "
+        + "given points at a different artifact than the one the absence is about" });
+  }
+  const crossChecked = Array.isArray(digestFindingUris) && digestFindingUris.length > 0;
+  return { computable: true,
+    reason: crossChecked ? null
+      : "no cross-check was possible — this run recorded no typed digest finding rows, so the "
+        + "population was not verified against an independent one",
+    population_empty: false, cross_checked: crossChecked,
+    // `checked` is the population this check actually walked, and `matched` how many of them the
+    // reconciliation ALSO named. On the delivery this was written for those are 70 and 0 — which is the
+    // whole point: a `matched` of zero used to mean "report nothing" and now means "the reconciliation
+    // saw none of them", a fact about the reconciliation rather than about the run.
+    checked: population.length, matched: diverged.filter((d) => d.reconciliation_agrees).length, diverged };
+}

package/driver/reference-score.mjs

@@ -667,14 +667,64 @@ export function scoreRecall({ reference, findings = [], retrieved = [], scopeCla
   // what it saw. Auto-promoting a collision to `found` would be the scorer manufacturing recall from
   // its own confusion, which is the defect one layer up from the one being fixed. score.mjs prints
   // these; a reader adjudicates.
+  // ── THE PREDICATE WAS THE OWNER, AND THE HEADING ABOVE SAYS RECORD (tracker issue 249) ──────────
+  //
+  // The only condition used to be `ownersMatch`. That implements a different class from the one the
+  // paragraph above states, and the justification — "they cannot both be true" — does not hold for any
+  // proprietor with more than one mark. A large filer can perfectly well have one mark the run withheld
+  // and a DIFFERENT mark, not in the reference, that it surfaced. Both rows are true.
+  //
+  // It fired on R2 russet-kestrel: `Novartis AG: reference "DELFITY" is withheld, surfaced "DELPHINA"
+  // is noise`. Different marks, different records, one proprietor that files a great many. And because
+  // score.mjs prints a collision as "do not read the recall numbers above", ONE such proprietor
+  // suppressed the whole run's recall measurement — a real 88% → 63% movement went unquoted on the
+  // regression issue because of a warning that was spurious.
+  //
+  // WHY NOT A RECORD JOIN, WHICH IS WHAT THE ISSUE ASKED FOR. Measured on the delivered artifact: a
+  // finding carries `{band, disposition, mark, meters, net, ordinal, owner, quadrant, source, …}` and
+  // NO record identity — `source.resolved_link` is empty on every row. Noise rows are built from
+  // findings, so there is nothing on that side to join a record URI to. Stating it here so the next
+  // reader does not re-derive it: the acceptance criterion is unmeetable on this side until a finding
+  // carries its record, and that is a change to the findings contract, not to the scorer.
+  //
+  // WHY NOT `matchesReference`, WHICH IS THE FILE'S OWN MARK MATCHER. It would make this check VACUOUS.
+  // The noise loop above already skips any finding that matches a reference entry, so by construction
+  // no noise row matches one — the collision would always be empty. This check exists precisely to
+  // catch the case where THE MATCHER DISAGREED WITH ITSELF, so it cannot be built out of the matcher.
+  //
+  // So the predicate is deliberately weaker than the matcher and stronger than the owner: same owner
+  // AND one mark contained in the other once normalised. That is the shape of the case this check was
+  // built for — `DELPHI GENETICS` in LOST beside `DG DELPHI GENETICS` in NOISE — and it is not the
+  // shape of `DELFITY` beside `DELPHINA`.
+  const collisionKey = (s) => String(s ?? "").normalize("NFKC").toUpperCase().replace(/[^A-Z0-9]/g, "");
+  // A FLOOR, because containment on a short string matches everything. `DEL` inside `DELPHINA` is not
+  // evidence of a shared record; four characters is the shortest reference mark shape worth trusting
+  // here, and a pair below it drops to the advisory rather than being dropped entirely.
+  const CONTAIN_FLOOR = 4;
   buckets.collisions = [];
+  buckets.ownerEchoes = [];
   for (const bucket of ["lost", "withheld"]) {
     for (const e of buckets[bucket]) {
       for (const n of buckets.noise) {
         if (!ownersMatch(e.owner, n.owner)) continue;
-        buckets.collisions.push({ bucket, entry: e.mark ?? e.name ?? null, noise: n.mark,
-          owner: ownerName(n.owner) ?? ownerName(e.owner),
-          why: `the reference entry is reported ${bucket} while a surfaced record of the SAME owner is reported noise — one record cannot be both` });
+        const a = collisionKey(e.mark ?? e.name);
+        const b = collisionKey(n.mark);
+        const row = { bucket, entry: e.mark ?? e.name ?? null, noise: n.mark,
+          owner: ownerName(n.owner) ?? ownerName(e.owner) };
+        const sameRecord = a && b
+          && Math.min(a.length, b.length) >= CONTAIN_FLOOR
+          && (a === b || a.includes(b) || b.includes(a));
+        if (sameRecord) {
+          buckets.collisions.push({ ...row,
+            why: `the reference entry is reported ${bucket} while a surfaced record of the SAME owner whose `
+              + "mark contains or is contained by it is reported noise — these are one record in two buckets" });
+        } else {
+          // REPORTABLE, NEVER SUPPRESSING. A reader may still want to see that a proprietor appears on
+          // both sides; what they must not be told is that the recall numbers are unreadable.
+          buckets.ownerEchoes.push({ ...row,
+            why: `same proprietor on both sides with different marks — not a contradiction: a filer may hold `
+              + `a reference mark this run ${bucket} and another, outside the reference, that it surfaced` });
+        }
       }
     }
   }

package/driver/reference-strip-signatures.mjs

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026 Cordillera Sàrl. Additional terms under section 7 of the AGPL-3.0 apply — see ADDITIONAL-TERMS.md
+//
+// THE TWO SIGNATURES THE REFERENCE STRIP LEFT BEHIND (tracker issue 185).
+//
+// The strip's job was to remove internal references from this repository before it went public, and it
+// did that. Where the reference was the SUBJECT of the sentence, it took the subject with it:
+//
+//     "[ref]'s design ruling — above any fold, only a statement…"   became   "'s design ruling — …"
+//     "renders the pre-[ref] section"                              became   "renders the pre- section"
+//
+// Neither construction occurs in written English, which is the whole reason they can be counted rather
+// than judged. A reader of a public repository meets them as sentences that do not finish, and one of
+// them is in user-facing configuration documentation rather than in a comment.
+//
+// WHAT THIS MODULE IS AND IS NOT. It finds them. It does not repair them: the repair is per-sentence and
+// needs somebody reading the surrounding code, because "the pre- section" means "the section as it was
+// before the findings contract changed" and only that reader can say so. The finding is mechanical and
+// costs nothing, so it is the part that ships as a check.
+export const SIGNATURES = [
+  {
+    name: "a comment beginning with a bare possessive",
+    // Anchored at the comment leader, so `it's` and `the run's` mid-sentence are untouched — only the
+    // case where the possessive has nothing in front of it to possess.
+    re: /^\s*(?:\/\/|#|\*)\s*'s\b/,
+  },
+  {
+    name: "`pre- ` followed by a lowercase word",
+    // The hyphen is left dangling by a stripped number. `pre-flight` and `pre-delivery` do not match:
+    // the strip's residue always leaves whitespace after the hyphen.
+    re: /\bpre-\s+[a-z]/,
+  },
+];
+
+// THE RULE'S OWN DEFINITION IS THE ONLY EXEMPTION, and it is named rather than pattern-matched.
+//
+// These three files QUOTE the residue in order to define it: the specimens in the arm, the examples in
+// the header above. Scanning them counts the definition as an instance, which puts the guard's own text
+// into the backlog it polices and makes every re-mint grow the number it exists to shrink. Caught by a
+// plant, not by review — they were untracked when the table was first minted, so `git ls-files` did not
+// list them and the census read a tree that did not include them yet.
+export const RULE_DEFINITIONS = [
+  "driver/reference-strip-signatures.mjs",
+  "driver/test/the-reference-strip-left-sentences-unfinished.test.mjs",
+  "scripts/mint-reference-strip-backlog.mjs",
+];
+
+/** Files worth scanning: prose-bearing, tracked, not generated, and not this rule's own definition. */
+export const isScannable = (f) =>
+  /\.(mjs|md|yml|ts)$/.test(f) && !f.startsWith("portal-ui/dist/") && !RULE_DEFINITIONS.includes(f);
+
+/**
+ * Count both signatures per file across `files`.
+ * `read` is injected so an arm can drive this over a synthetic tree — a census helper that can only
+ * read the real repository cannot be planted, and a plant is the only thing that proves it still counts.
+ */
+export function censusOf(root, files, read) {
+  const out = {};
+  let total = 0;
+  for (const f of files.filter(isScannable)) {
+    let text;
+    try { text = read(f); } catch { continue; }          // binary or unreadable — nothing to count
+    const counts = SIGNATURES.map((s) => text.split("\n").filter((l) => s.re.test(l)).length);
+    if (counts.some((n) => n > 0)) { out[f] = counts; total += counts.reduce((a, b) => a + b, 0); }
+  }
+  // Sorted, so a re-mint produces a reviewable diff instead of a reordered file.
+  return { total, files: Object.fromEntries(Object.entries(out).sort(([a], [b]) => a < b ? -1 : 1)) };
+}

package/driver/register-digest-record.mjs

@@ -168,6 +168,36 @@ const FINDING_COLUMNS = Object.freeze(
 // finding it there together with screen_verdict / class / status.
 const NEGATIVE_COLUMNS = Object.freeze(["Mark", "Search Term / Variant", "Result", "Notes"]);
 
+/**
+ * The "Mark" cell for one Negative-results row.
+ *
+ * A `duplicate-of-surfaced` row is not a statement about the MARK. It is a statement about one
+ * registration of a mark whose position is already reported above it — the digest's own rule is "one
+ * row per POSITION, never one per registration of the same right". Printing the bare mark under a
+ * column headed "Mark" says the opposite of what the row means, and the document then reads as both
+ * "keep this mark, here is the reasoning" in the incumbent table and "no separate row for this mark"
+ * here. Nine readers scan this file, and one of them is the drafting seat that decides what the client
+ * is shown.
+ *
+ * Naming the record removes the contradiction and changes no judgment the digest made: the row is
+ * still a drop, still on the same ground, still carrying the seat's own reason.
+ *
+ * ✕ EVERY OTHER GROUND IS LEFT ALONE, deliberately. `off-field`, `dead-status` and `out-of-class` are
+ * about the record on its own terms, where the bare mark is what a reader wants and is not ambiguous.
+ * A blanket change to this column would touch every negative row in every report for a defect that
+ * only exists on the duplicate class.
+ *
+ * The office comes from the record uri (`/mark/wo/…` -> `WO`); every uri in the archived corpus carries
+ * a two-letter office in that position. When it cannot be read the BARE MARK is printed rather than a
+ * broken qualifier — a missing qualifier is a smaller defect than "OSLER DELPHI — UNDEFINED record".
+ */
+export function negativeMarkCell(row) {
+  const mark = String(row?.cells?.mark ?? "").trim();
+  if (row?.ground !== "duplicate-of-surfaced" || !mark) return mark;
+  const office = String(row?.cells?.uri ?? "").split("/")[2] ?? "";
+  return /^[a-z]{2}$/i.test(office) ? `${mark} \u2014 ${office.toUpperCase()} record` : mark;
+}
+
 // ── THE FLOOR, AND WHAT ITS ZERO MEANS ────────────────────────────────────────────────────────────
 //
 // `validators.registerFindings` carried `nonEmpty(c)` with no character number, so there is no
@@ -353,7 +383,7 @@ export function renderRegisterFindings(model, facts = emptyFacts()) {
   out.push(DIGEST_SECTIONS.negative, "");
   out.push(model.negative_rows.length
     ? table(NEGATIVE_COLUMNS, model.negative_rows.map((r) => [
-      r.cells.mark, r.variant || r.cells.mark, r.drop_reason,
+      negativeMarkCell(r), r.variant || r.cells.mark, r.drop_reason,
       [`URI ${r.cells.uri}`, r.screen_verdict ? `screen_verdict=${r.screen_verdict}` : "",
         r.cells.classes ? `class=${r.cells.classes}` : "", r.cells.status ? `status=${r.cells.status}` : ""]
         .filter(Boolean).join("; "),

package/driver/repairs.mjs

@@ -555,7 +555,7 @@ export function countRecoveryLanes(history, { total = 0 } = {}) {
 
 // ── CAP PARKS: A PROVIDER SAYING "NOT YET" IS NOT A STAGE FAILING (tracker issue 103) ──────────────
 //
-// Owner, watching indigo-falcon spend 4 of its 6 recovery parks against one subscription cap:
+// Owner, watching a run spend 4 of its 6 recovery parks against one subscription cap:
 //
 //   "surely it can work out when the cap expires and try after that time and not just keep trying
 //    and then die."

package/driver/suite-census.json

@@ -189,6 +189,12 @@
           "skips": 1,
           "todos": 0
         },
+        "a-door-that-is-not-there-is-not-a-door-that-agrees.test.mjs": {
+          "tests": 19,
+          "asserts": 69,
+          "skips": 0,
+          "todos": 0
+        },
         "a-doubt-cannot-answer-itself.test.mjs": {
           "tests": 17,
           "asserts": 40,
@@ -201,6 +207,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-drop-with-a-stated-reason-is-checked.test.mjs": {
+          "tests": 13,
+          "asserts": 32,
+          "skips": 0,
+          "todos": 0
+        },
         "a-fact-about-a-named-party.test.mjs": {
           "tests": 30,
           "asserts": 80,
@@ -376,8 +388,8 @@
           "todos": 0
         },
         "a-real-install-starts-with-an-empty-archive.test.mjs": {
-          "tests": 3,
-          "asserts": 8,
+          "tests": 6,
+          "asserts": 16,
           "skips": 0,
           "todos": 0
         },
@@ -483,6 +495,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-screenshot-of-an-error-page-is-not-a-report.test.mjs": {
+          "tests": 17,
+          "asserts": 44,
+          "skips": 4,
+          "todos": 0
+        },
         "a-secret-file-is-compared-not-printed.test.mjs": {
           "tests": 5,
           "asserts": 16,
@@ -501,6 +519,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-shared-proprietor-is-not-a-bucket-collision.test.mjs": {
+          "tests": 6,
+          "asserts": 14,
+          "skips": 0,
+          "todos": 0
+        },
         "a-signal-immune-fixture-is-reaped-by-its-owner.test.mjs": {
           "tests": 10,
           "asserts": 20,
@@ -724,8 +748,8 @@
           "todos": 0
         },
         "ask-ledger.test.mjs": {
-          "tests": 21,
-          "asserts": 100,
+          "tests": 26,
+          "asserts": 119,
           "skips": 0,
           "todos": 0
         },
@@ -1882,8 +1906,8 @@
           "todos": 0
         },
         "example-replay.test.mjs": {
-          "tests": 6,
-          "asserts": 24,
+          "tests": 8,
+          "asserts": 31,
           "skips": 0,
           "todos": 0
         },
@@ -2826,7 +2850,7 @@
         "production-dependencies.test.mjs": {
           "tests": 4,
           "asserts": 7,
-          "skips": 0,
+          "skips": 3,
           "todos": 0
         },
         "products.test.mjs": {
@@ -2964,7 +2988,7 @@
         "reading-the-demo-does-not-edit-the-repository.test.mjs": {
           "tests": 2,
           "asserts": 8,
-          "skips": 0,
+          "skips": 1,
           "todos": 0
         },
         "reason-cut-is-visible.test.mjs": {
@@ -3076,8 +3100,8 @@
           "todos": 0
         },
         "reference-score-owner-identity.test.mjs": {
-          "tests": 9,
-          "asserts": 30,
+          "tests": 10,
+          "asserts": 34,
           "skips": 0,
           "todos": 0
         },
@@ -3160,8 +3184,8 @@
           "todos": 0
         },
         "register-digest-record.test.mjs": {
-          "tests": 30,
-          "asserts": 102,
+          "tests": 32,
+          "asserts": 114,
           "skips": 0,
           "todos": 0
         },
@@ -3238,8 +3262,8 @@
           "todos": 0
         },
         "release-pipeline.test.mjs": {
-          "tests": 52,
-          "asserts": 243,
+          "tests": 83,
+          "asserts": 320,
           "skips": 0,
           "todos": 0
         },
@@ -4335,6 +4359,12 @@
           "skips": 0,
           "todos": 0
         },
+        "the-reference-strip-left-sentences-unfinished.test.mjs": {
+          "tests": 6,
+          "asserts": 13,
+          "skips": 3,
+          "todos": 0
+        },
         "the-repair-order-and-the-tool-schema-agree.test.mjs": {
           "tests": 6,
           "asserts": 27,
@@ -5043,8 +5073,8 @@
           "todos": 0
         },
         "whatif.test.mjs": {
-          "tests": 9,
-          "asserts": 29,
+          "tests": 10,
+          "asserts": 32,
           "skips": 0,
           "todos": 0
         }

package/driver/verify.mjs

@@ -170,8 +170,8 @@ function needs(content, markers, label, names = []) {
 //
 // THE CLASS. Every gate below keys on prose the MODEL composes, so each is one phrasing drift away
 // from killing a run that produced the section perfectly. Measured across three runs and two engines:
-// pewter-lantern (codex) wrote "## Negative-results matrix" and was rejected twice, killing a client
-// run; umber-beacon (anthropic) wrote "## Negative results (per-cell detail)" — different spelling AND
+// one run on codex wrote "## Negative-results matrix" and was rejected twice, killing the run; another
+// on anthropic wrote "## Negative results (per-cell detail)" — different spelling AND
 // different trailing words, same skill. PR 336 widened the regex to `[\s-]`, which fixed those two
 // instances and left the class exactly where it was: the gate still asks the model to guess a spelling.
 //

package/mcp-server/CHANGELOG.md

@@ -1,5 +1,13 @@
 # trademark-artifacts-mcp
 
+## 0.2.1
+
+## 0.2.1-beta.2
+
+## 0.2.1-beta.1
+
+## 0.2.1-beta.0
+
 ## 0.2.0
 
 ## 0.1.12

package/mcp-server/lib/whatif.mjs

@@ -252,7 +252,16 @@ export async function whatIfRun({ confirmationToken } = {}, deps = {}) {
     // askArchivedRun answers {ok:true, memoPath, memoId, parentRunId, assumption, ratedUnder,
     // statedLimits} or {ok:false, fail, detail} — a stable MEMO_FAILS code, never a throw, because the
     // worker records what it is handed and a throw there becomes a string nobody can branch on.
-    return await askArchivedRun({ runId, question: instructions, requestedBy: null });
+    // THE RESOLVER IS HANDED OVER, and this line is the whole of tracker issue 132's first defect.
+    // `askArchivedRun` takes its resolver from `deps` and has no default for it — `reason` was given one
+    // and `resolveRun` was not — so calling it bare returned `memo_run_unresolved` for every memo on
+    // every run, while `resolveRun(runId)` eight lines above had already resolved that same run fine.
+    // The capability was composed, the door opened, and no production caller could execute it.
+    // ✕ NOT fixed by defaulting inside driver/whatif-memo-run.mjs: `resolveRun` lives in this layer
+    // (./runs.mjs), and a default there would make the driver import the mcp-server, which is the
+    // dependency this module's own comment above keeps out of module scope. This is the only production
+    // call site — `driver/whatif-worker.mjs` does not call `askArchivedRun` at all.
+    return await askArchivedRun({ runId, question: instructions, requestedBy: null }, { resolveRun });
   }
 
   const refusal = whatIfRefusal({ location: run.location, state: run.state });

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-artifacts-mcp",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "MCP server to interrogate prelim trademark-clearance runs — list/read artifacts, trace the full decision flow, telemetry/cost, coverage, single-run search, and a gated single-step what-if. Imports the prelim-driver read-only; touches no driver/template/deploy files.",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clearotron",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

package/portal-ui/package.json

@@ -2,7 +2,7 @@
   "name": "portal-ui",
   "private": true,
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "AGPL-3.0-only",
   "description": "The unified trademark portal UI. One address, one login: who you are decides what you see. Built as a static bundle, served by driver/portal-service.mjs — the browser never reaches profile-service or recipe-service.",
   "engines": {

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

@@ -1,5 +1,13 @@
 # trademark-oauth-mcp-bridge
 
+## 0.2.1
+
+## 0.2.1-beta.2
+
+## 0.2.1-beta.1
+
+## 0.2.1-beta.0
+
 ## 0.2.0
 
 ## 0.1.12