clearotron 0.3.3 → 0.4.0-beta.1

package/driver/publish/knockout.mjs

@@ -9,7 +9,7 @@
 // can never drift and a knockout never reads the clearance composer's module state.
 import { readFileSync, writeFileSync, copyFileSync, mkdirSync, chmodSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { driverDir, ensureDriverDir } from '../../shared/driver-dir.mjs';   //
+import { driverDir, ensureDriverDir, RUN_DIR_MODE } from '../../shared/driver-dir.mjs';   //
 import { riskTier, TONE_TIER, regenIndex, regenSurfaces, auditRouteFor, markReportRouteFor, reportRouteFor } from './index.mjs';
 import { runKnockoutLint, deliveryFlagLines } from '../predelivery-lint.mjs';
 import { note } from '../log.mjs';
@@ -334,7 +334,8 @@ export async function publishKnockout({ runId, codename, runDir, findings, plan,
   // assumed: `urls: 0` in the receipt below means no finding cited anything.
   note(`knockout receipts: ${receipts.checked.urls} citation(s) across ${receipts.checked.findings} finding(s) on ${receipts.checked.citing}/${receipts.checked.marks} mark(s) traced to held evidence`);
   const poolRunDir = join(poolRoot, runId);
-  mkdirSync(poolRunDir, { recursive: true });
+  // Owner and group only: a mode given to mkdir, which keeps the set-GID the pool root passes down.
+  mkdirSync(poolRunDir, { recursive: true, mode: RUN_DIR_MODE });
   const writeRO = (name, data) => { const p = join(poolRunDir, name); writeFileSync(p, data); grpRead(p, 0o640); };
 
   // ── THE RUN'S WORKING RECORD TRAVELS WITH THE REPORT ──────────────────────────────────────────────

package/driver/publish/render-knockout.mjs

@@ -536,7 +536,7 @@ function countsSection(marks, registerCounts, positions = '') {
   // Close variations — did not say what they counted, so the definition had to go somewhere. Put it in
   // the header and the paragraph has nothing left to do.
   //
-  // ONE NAME ⇒ THE HEADER NAMES IT, because "Exactly ORBIT" needs no gloss at all. Several names share
+  // ONE NAME ⇒ THE HEADER NAMES IT, because "Exactly ACME" needs no gloss at all. Several names share
   // one table and no header can name one of them, so they keep the general form and each row's own
   // forms line (already rendered, unchanged) carries that row's near-spellings.
   const single = marks.length === 1 ? String(marks[0]?.name ?? '').trim() : '';

package/driver/publish/render.mjs

@@ -70,6 +70,9 @@ let CASE_LAW_BY_ORD = new Map();   // E5: ordinal → grounded case-law profile
 // is full-country only), so suppressing there would take case-law off the page with nothing left
 // saying so. Absence of a state is not a statement that nothing was found.
 let COURT_DECISIONS = null;
+// The company picked no marketplaces (search-depth counts.sweep): the use-check's nothing-found line names the
+// general web and the stores chosen for the matter instead of a marketplace search. Set per render.
+let NO_MARKETPLACES_PICKED = false;
 let ENFORCER_SIGNALS = new Map();  // E6: registration uri (lowercase) → {aggression, oppositions, owner}
 // WP-receipts W2 — per-render provider record-link origin + label, resolved by publish from the run's
 // OWN _driver/receipts.json provider (never the currently-configured provider — a re-published archive
@@ -552,6 +555,9 @@ const useEvidence = (m) => [USE_EVIDENCE_LABEL[m?._status], USE_SOURCE_LABEL[m?.
 // runs carry the old value forever and a fourth spelling of it would have to be accepted everywhere.
 const USE_CHECK_NO_RESULT = 'perplexity_research — no result';
 const USE_CHECK_NO_RESULT_CITE = 'Nothing found in the marketplaces searched.';
+// The same "searched, nothing found" line for a run whose company picked no marketplaces (the owner's
+// ruling of 2026-09-23): there was no marketplace search to name, and the general web still ran.
+const USE_CHECK_NO_RESULT_CITE_NO_MARKETPLACES = 'Nothing found in the general web search or in any store chosen for this matter.';
 // — MATCHED ON NORMALISED PUNCTUATION, NOT ONE SPELLING. The constant itself does not
 // move (archived runs carry it forever, the validators name it), but the SEAT emitted a hyphen where
 // the doctrine writes an em dash, and exact equality let the raw tool name through to a delivered
@@ -1222,7 +1228,9 @@ function whatWasSearchedSection(opts, coverage = [], findings = [], recordsByUri
   }
   const sw = c.sweep || {};
   if (sw.spellings) rows.push(['Spellings searched', String(sw.spellings)]);
-  if (sw.checks) rows.push(['Marketplace and web', `${sw.checks.toLocaleString('en-GB')} checks on ${sw.platforms} platforms`]);
+  if (sw.checks) rows.push(['Marketplace and web', sw.noMarketplacesPicked
+    ? `${sw.checks.toLocaleString('en-GB')} checks: the general web, plus any stores chosen for this matter.`
+    : `${sw.checks.toLocaleString('en-GB')} checks on ${sw.platforms} platforms`]);
   if (sw.reputation) rows.push(['Reputation and meaning', `${sw.reputation.toLocaleString('en-GB')} checks`]);
   rows.push(['Local-script spellings', c.localScriptSearched ? 'Searched' : 'Not searched']);
   // HOW DEEP THE LOCAL-LANGUAGE INVESTIGATION WENT, which is a different question from the row above it.
@@ -1803,7 +1811,9 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   const useStatus = useEvidence(f.meters?.use);
   // D7 — the code-owned "searched, nothing found" sentinel becomes client words HERE, by exact
   // equality against the one constant. Any other value is a source string and rides through untouched.
-  const useSrc = isUseCheckNoResult(f.use_check?.source) ? USE_CHECK_NO_RESULT_CITE : f.use_check?.source;
+  const useSrc = isUseCheckNoResult(f.use_check?.source)
+    ? (NO_MARKETPLACES_PICKED ? USE_CHECK_NO_RESULT_CITE_NO_MARKETPLACES : USE_CHECK_NO_RESULT_CITE)
+    : f.use_check?.source;
   // NO EVIDENCE TAG ON AN EMPTY RESULT. The line read "Use checked. Marketplace search run — no result
   // found. Evidence: inferred", and "inferred" beside "no result" reads as a contradiction: it qualifies
   // how a FINDING was established, and there is no finding here. Nothing was found, and that is the
@@ -2276,7 +2286,7 @@ ${EXPORT_MENU_JS}`;
 // Render a parsed report + findings.json to a full self-contained HTML string.
 // A1 — famous-neighbour context notes: knowledge-cited references kept for diligence (digest.md's "never
 // dropped" rule) that carry NO fetched register record, so they are NOT findings and do NOT score. Rendered
-// on BOTH the internal and client report (legitimate completeness — "we checked CHROME, it isn't a
+// on BOTH the internal and client report (legitimate completeness — "we checked NOVAPULSO, it isn't a
 // conflict"), clearly marked as not-a-conflict so a famous neighbour is surfaced, never silently lost.
 // WP-56 B2 — the standing "mark itself" section: typed mark_assessment (findings-model, both parsers) →
 // code render at the TOP of the page (after the hero, before the conflict landscape), on THE report.
@@ -2511,6 +2521,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   SCOPE_WORLDWIDE = opts.scopeBasis === 'worldwide' ? true : null;   // the plan's scope_basis; null ⇒ fall back to the ledger-prose sniff
   CASE_LAW_BY_ORD = opts.caseLawByOrdinal instanceof Map ? opts.caseLawByOrdinal : new Map();   // T7 (E5)
   COURT_DECISIONS = opts.searchDepth?.counts?.courtDecisions ?? null;   // gates the card's case-law strand
+  NO_MARKETPLACES_PICKED = opts.searchDepth?.counts?.sweep?.noMarketplacesPicked === true;
   ENFORCER_SIGNALS = new Map((Array.isArray(opts.enforcerSignals) ? opts.enforcerSignals : []).map((e) => [String(e.uri ?? '').toLowerCase(), e]));   // T7 (E6)
   RECORD_ORIGIN = opts.recordOrigin ?? null;       // WP-receipts W2
   // — `null` and `` mean DIFFERENT things and the render must not collapse them. `` is an

package/driver/publish/search-depth.mjs

@@ -275,7 +275,7 @@ export function localScriptSearched(registerPlan) {
  *
  * @returns {{schemaVersion: number, cleared: object, counts: object}}
  */
-export function searchDepthRecord({ auditMd = "", recordIndex = {}, recordFileNames = [], bandRecordIds = null, commonLawGrid = null, caseLawText = "", registerPlan = null, laneDepthVerdicts = null } = {}) {
+export function searchDepthRecord({ auditMd = "", recordIndex = {}, recordFileNames = [], bandRecordIds = null, commonLawGrid = null, caseLawText = "", registerPlan = null, laneDepthVerdicts = null, noMarketplacesPicked = false } = {}) {
   // `recordFileNames: null` travels all the way to the page — see recordsByCountry. The default stays `[]`
   // because that is "the caller said nothing", not "the store is absent"; only the publish path knows the
   // difference and it is the one producer.
@@ -295,7 +295,9 @@ export function searchDepthRecord({ auditMd = "", recordIndex = {}, recordFileNa
     counts: {
       recordsByCountry: recordsByCountry(recordFileNames),
       recordsRead: recordFileNames === null ? null : recordFileNames.length,
-      sweep: sweepCounts(commonLawGrid, auditMd),
+      // The company picked no marketplaces: the report says the general web ran plus any stores chosen for
+      // the matter. Stamped only when true, so every other run's record is unchanged.
+      sweep: { ...sweepCounts(commonLawGrid, auditMd), ...(noMarketplacesPicked ? { noMarketplacesPicked: true } : {}) },
       localScriptSearched: localScriptSearched(registerPlan),
       courtDecisions: courtDecisionsState(caseLawText),
       // `localScriptSearched` above answers whether the spellings were searched; this answers how deep

package/driver/recall-reconciliation.mjs

@@ -30,7 +30,7 @@
 // The first cut had two contracts joined only by prose: digest.md told the digest to write ONE
 // Sheet-1 row per POSITION (the exact-identity collapse), while this join credited an ending only to
 // the URIs literally cited, with no notion of positions. Proven on real records: /mark/cn/CHINIC4DC…
-// and /mark/cn/CHINIC7788… (both TIKI TWIST, NORTHCOMEX USA LLC, class 32, REGISTERED) are ONE
+// and /mark/cn/CHINIC7788… (both WAVO TWIST, NORTHCOMEX USA LLC, class 32, REGISTERED) are ONE
 // position AND both sit in the code-ranked top slice — a compliant digest writing one position row
 // citing the senior URI left the other unended and the delivery died. The only thing standing
 // between a correct report and a blocked run was a prose clause ("the URI cell listing EVERY

package/driver/record-carry.mjs

@@ -10,7 +10,7 @@
 // `register-named-band.json`, all ten screened `surface:in-scope-live`, and not one of them appears in
 // `placements.json` or in `findings.json`. The delivered report never names the token. The record was
 // retrieved, screened and banded, and then it was gone, and NOTHING anywhere recorded why. The same
-// shape had already been paid for four times (TIKI TWIST / TIKI TROPICS on R3, DELPHIC / OSLER DELPHI
+// shape had already been paid for four times (WAVO TWIST / WAVO TROPICS on R3, KORPHIC / HALVER KORPHI
 // on R2). A capability that retrieves and cannot deliver is indistinguishable, in the report, from one
 // that was never built — and the two have completely different fixes.
 //
@@ -842,10 +842,10 @@ export function silentlyLostFindings({ reconciliation = null, carryRows = null,
  *
  * MEASURED ON A DELIVERED R2 RUN, 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
+ * list, `HALVER KORPHI` and `KORFITY`, 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
+ *   IMMATERIAL ask:recall:recall-halver-korphi: … — HALVER KORPHI / Halver 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
@@ -886,11 +886,11 @@ export function statedDivergenceFindings({ reconciliation = null, carryRows = nu
   //   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 — VELTRIN
-  // bioenergetische Kosmetik, DELPHIC HSE, DELPHI, DELPHIN & EMERENCE, DELPHI DIAGNOSTICS. The two that
+  // bioenergetische Kosmetik, KORPHIC HSE, KORPHI, DELPHIN & EMERENCE, KORPHI 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
+  //   HALVER KORPHI  reach=placed stopped_at=digest reason_source=step-stated reason=digest:reasoned-negative
+  //   KORFITY       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

package/driver/recording-agreement.mjs

@@ -205,7 +205,7 @@ export function agreementFindings({ stage, granted, artifacts, union, toolUniver
     if (!PHASES.includes(m.phase)) {
       throw new Error(`recording-agreement: instruction member "${m.surface}" carries phase `
         + `${JSON.stringify(m.phase)} — every INSTRUCTION member must declare ${ATTEMPT_1} or ${REPAIR}, `
-        + "because direction (a) counts only what the seat reads on attempt 1 (#1190)");
+        + "because direction (a) counts only what the seat reads on attempt 1");
     }
   }
   const attempt1 = instructions.filter((m) => m.phase === ATTEMPT_1);
@@ -240,7 +240,7 @@ export function agreementFindings({ stage, granted, artifacts, union, toolUniver
       why: `${stage} holds ${tool} and no attempt-1 instruction names it. The seat is not told the `
         + "capability exists, so it reaches for whatever the doctrine DOES name — which after a "
         + "conversion is a tool its grant no longer carries. Name it in the dispatch or in the skill doc, "
-        + "or drop it from the grant. A repair rung naming it does NOT count (#1190): the seat that "
+        + "or drop it from the grant. A repair rung naming it does NOT count: the seat that "
         + "needed to know had already acted by the time it read one.",
     });
   }

package/driver/reference-score.mjs

@@ -117,11 +117,11 @@ export function labelTokens(label) {
  *
  * The two separator classes do different work and conflating them is the bug worth stating. `/ , · & |`
  * separate ALTERNATIVES for the same record: `VENZAL / VENZALMONO / VENZALKOMB` is one relabelled entry,
- * and `CHROMA / & Device` is one mark plus a device note. Whitespace and hyphens separate WORDS WITHIN
- * one name: `TIKI TWIST` is not `TIKI`.
+ * and `LUMIVANE / & Device` is one mark plus a device note. Whitespace and hyphens separate WORDS WITHIN
+ * one name: `WAVO TWIST` is not `WAVO`.
  *
  * Treating a word separator as an alias separator makes every multi-word mark match its own first word —
- * so a reference `TIKI` would claim the run's `TIKI TWIST`, and a genuinely withheld mark would be
+ * so a reference `WAVO` would claim the run's `WAVO TWIST`, and a genuinely withheld mark would be
  * reported as found. That is a false clean on the exact pair this scorer was built for.
  */
 /*
@@ -151,7 +151,7 @@ export function labelAliases(label) {
     .filter(Boolean);
 }
 
-/** The consonant skeleton is only discriminating once there is enough of it. TIKI and TIKA are both "tk". */
+/** The consonant skeleton is only discriminating once there is enough of it. WAVO and WAVA are both "wv". */
 const MIN_SKELETON = 4;
 
 // asked for a minimum ALIAS length, or a stated reason there is none. THERE IS NONE, deliberately.
@@ -190,20 +190,20 @@ const MIN_SKELETON = 4;
  *     can tell an exact CJK match from an owner-gated one.
  *  2. ALIAS. Any alias of one label equals any alias of the other, compared as whole names. This is what
  *     makes `VENZAL` match `VENZAL / VENZALMONO / VENZALKOMB` — the relabelling an exact diff misreads
- *     as a drop plus a find — while keeping `TIKI` and `TIKI TWIST` apart.
+ *     as a drop plus a find — while keeping `WAVO` and `WAVO TWIST` apart.
  *  3. SKELETON. Consonant skeletons of 4+ characters agree. Reaches the one-vowel spelling pairs a variant
- *     sweep must not split, without letting short marks collide — 4 is the floor because TIKI and TIKA
+ *     sweep must not split, without letting short marks collide — 4 is the floor because WAVO and WAVA
  *     both skeletonise to "tk".
  *  4. CONTAINED — ONLY when the caller has established that both sides carry the SAME OWNER.
  *     One label's word sequence sits contiguously inside the other's. Rules 2 and 3 handle a reference
  *     mark being an ALIAS of, or a spelling neighbour of, a surfaced one; neither handles it being
- *     CONTAINED in one, and that is how `DELPHI GENETICS` and `DG DELPHI GENETICS` — identical owner,
+ *     CONTAINED in one, and that is how `KORPHI GENETICS` and `DG KORPHI GENETICS` — identical owner,
  *     one record — were filed as a `lost` and a `noise` on the same run. A record cannot be both never
  *     retrieved and surfaced-but-unknown, and the entry it split was the reference's highest-risk one.
  *
- *     READ WITH RULE 2, NOT AGAINST IT (2026-08-14). Rule 2's block says the alias rule "keeps `TIKI`
- *     and `TIKI TWIST` apart", and this rule joins exactly that pair under a matched owner —
- *     `matchesReference("TIKI", "TIKI TWIST", {sameOwner:true})` returns `contained`. Both are right
+ *     READ WITH RULE 2, NOT AGAINST IT (2026-08-14). Rule 2's block says the alias rule "keeps `WAVO`
+ *     and `WAVO TWIST` apart", and this rule joins exactly that pair under a matched owner —
+ *     `matchesReference("WAVO", "WAVO TWIST", {sameOwner:true})` returns `contained`. Both are right
  *     and they read as contradictory side by side. Rule 2 asks whether two labels are the SAME NAME,
  *     where a word separator must never collapse a longer mark into its first word. Rule 4 asks a
  *     different question that only an established owner match makes answerable: whether ONE PROPRIETOR
@@ -211,7 +211,7 @@ const MIN_SKELETON = 4;
  *     resolving the apparent conflict by narrowing either one would break the case it was built for.
  *
  *     OWNER IDENTITY IS THE DISCRIMINATOR, and it is the whole reason this rule is safe. Containment on
- *     its own would pull `Delphi Pharmaceuticals` and `Delphi Laboratories` into `found` and manufacture
+ *     its own would pull `Korphi Pharmaceuticals` and `Korphi Laboratories` into `found` and manufacture
  *     recall the run does not have — five such marks sit in this very scenario's own results. Gated on
  *     `ownersMatch`, it reaches exactly the case it is for: one proprietor, one record, two renderings.
  *     The caller establishes the owner agreement; this function never guesses it.
@@ -577,8 +577,8 @@ export function scoreRecall({ reference, findings = [], retrieved = [], scopeCla
     // This was `retrieved.find(heldRule)` — the FIRST match in band order, with nothing preferring the
     // entry's own proprietor. Measured on a 2026-08-27 test run against its lawyer reference: of eight entries,
     // five matched more than one band record and three cited the wrong company. For two of those three
-    // the RIGHT record was already in the match set and was passed over on position alone — DELPHIC's at
-    // index 1, DELPHYS's at index 3.
+    // the RIGHT record was already in the match set and was passed over on position alone — KORPHIC's at
+    // index 1, VELTRYS's at index 3.
     //
     // The looseness of the matcher is NOT the fault here and is deliberately left alone. Only one of the
     // three wrong citations came from a skeleton collision; the other two were `alias` matches — the
@@ -598,8 +598,8 @@ export function scoreRecall({ reference, findings = [], retrieved = [], scopeCla
     const entryNamesOwner = Boolean(ownerKey(e?.owner));
     if (heldAll.length) {
       // AMONG THE OWNER'S OWN RECORDS, PREFER THE CLOSEST NAME. `heldOwned[0]` is band order again, one
-      // level down: DELPHIC's owner holds several records and the first is `DELPHIC ADAPTABLE`, while the
-      // lawyer named plain `DELPHIC`. Right proprietor, wrong record of theirs. An `alias` rule is an
+      // level down: KORPHIC's owner holds several records and the first is `KORPHIC ADAPTABLE`, while the
+      // lawyer named plain `KORPHIC`. Right proprietor, wrong record of theirs. An `alias` rule is an
       // identity match on the name; `skeleton` and `contained` are near-forms. Take an identity match
       // when the owner has one.
       const strongest = (rows) => rows.find((r) => heldRule(r) === "alias") ?? rows.find((r) => heldRule(r) === "script") ?? rows[0] ?? null;
@@ -681,7 +681,7 @@ export function scoreRecall({ reference, findings = [], retrieved = [], scopeCla
   // 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 a delivered R2 run: `<large filer>: reference "DELFITY" is withheld, surfaced "DELPHINA"
+  // It fired on a delivered R2 run: `<large filer>: reference "KORFITY" is withheld, surfaced "KORPHINA"
   // 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
@@ -701,10 +701,10 @@ export function scoreRecall({ reference, findings = [], retrieved = [], scopeCla
   //
   // 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`.
+  // built for — `KORPHI GENETICS` in LOST beside `DG KORPHI GENETICS` in NOISE — and it is not the
+  // shape of `KORFITY` beside `KORPHINA`.
   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
+  // A FLOOR, because containment on a short string matches everything. `KOR` inside `KORPHINA` 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;
@@ -783,7 +783,7 @@ export function withheldScope({ reference = [], retrieved = [], registerOnly = f
     : !marks.length
       ? `${scopeOf} — and the retrieved corpus is EMPTY, so this number rests on nothing; it is not a clean result`
       : outside
-        ? `${scopeOf} — ${outside} other retrieved mark${outside === 1 ? "" : "s"} are outside this measure entirely (#1322)`
+        ? `${scopeOf} — ${outside} other retrieved mark${outside === 1 ? "" : "s"} are outside this measure entirely`
         : `${scopeOf} — all ${marks.length} retrieved mark${marks.length === 1 ? " is" : "s are"} named by the reference, so nothing sits outside it`;
   return { referenceEntries: n, retrievedMarks: marks.length, outside, note };
 }
@@ -859,7 +859,7 @@ export function scoreField({ reference = [], findings = [] }) {
     if (e.on_field !== true) continue;
     const label = e.mark ?? e.name ?? "";
     // — the SAME question axis A asks, owner agreement included. Left out, this axis reported
-    // `DELPHI GENETICS` as "not-surfaced — cannot be scored on field" on the very run where axis A had
+    // `KORPHI GENETICS` as "not-surfaced — cannot be scored on field" on the very run where axis A had
     // just matched it. One record, two axes, two answers is the defect this issue names, and the axis
     // that cannot see the finding is the one that decides whether its GOODS were routed correctly.
     const f = findings.find((x) => matchesReference(label, x.mark, { sameOwner: ownersMatch(e?.owner, x?.owner) }));
@@ -1515,7 +1515,7 @@ export function concludeDepth({ instructed = [], rows = [], resolved = true, why
  *
  * Common and Inherited are excluded from the run and every run must contain a real LETTER, so an
  * accented Latin mark in NFD (`CAFE` + U+0301, whose combining mark is Inherited) is not a script
- * segment, and neither is punctuation, a device note or a digit. `CHROMA / & Device` yields nothing;
+ * segment, and neither is punctuation, a device note or a digit. `LUMIVANE / & Device` yields nothing;
  * `色度 / SEDU` yields the segment the jx lane has to generate. PURE.
  */
 export function scriptSegments(label) {
@@ -1534,8 +1534,8 @@ export function scriptSegments(label) {
 /**
  * CORPORATE LEGAL FORMS, DROPPED FROM AN OWNER KEY ONLY —.
  *
- * `NOISE_TOKENS` covers US, UK and German forms and almost nothing else, so `BePharBel Manufacturing`
- * and `BePharBel Manufacturing, Société anonyme` read as two companies. Measured: of twenty common forms
+ * `NOISE_TOKENS` covers US, UK and German forms and almost nothing else, so `DuPharVel Manufacturing`
+ * and `DuPharVel Manufacturing, Société anonyme` read as two companies. Measured: of twenty common forms
  * appended to an otherwise identical name, NINETEEN broke the match — only `S.A.` survived, and only
  * because `sa` happens to be on that list.
  *
@@ -1608,11 +1608,11 @@ export function ownerKey(owner) {
   const n = ownerName(owner);
   if (!n) return null;
   // — DROP A TRAILING PARENTHETICAL ANNOTATION. A gold set is lawyer-typed, and the convention in
-  // it is a jurisdiction hint after the name: `Delphi Genetics S.A. (BX)`, `Delphi Diagnostics, Inc.
+  // it is a jurisdiction hint after the name: `Korphi Genetics S.A. (BX)`, `Korphi Diagnostics, Inc.
   // (US)` — three of R2's nine entries carry one and six do not, which is what makes it an annotation
   // rather than part of any name. A run finding carries the typed owner object and never one of these,
   // so the strict token-set equality below could not match the two sides of the SAME proprietor, and
-  // `Delphi Genetics S.A.` scored against `Delphi Genetics S.A. (BX)` as a different company.
+  // `Korphi Genetics S.A.` scored against `Korphi Genetics S.A. (BX)` as a different company.
   //
   // ONE trailing group, and only at the end. This is not a general parenthesis fold: a parenthetical
   // inside a name is part of the name, and `Shanghai <A> Network Technology` vs `Shanghai <B> Network
@@ -1911,7 +1911,7 @@ export function scoreScriptTargets({ reference = [], buckets = {}, findings = []
 // ── — A KNOCKOUT IS GRADED ON WHAT A KNOCKOUT PROMISES ─────────────────────────────────────────
 //
 // R3 and R4 are knockout scenarios and their gold sets are clearance-grade lawyer reviews listing
-// SIMILAR marks — TIKI PUNCH, TIKI TROPICS — which a count of the exact string and its close variations
+// SIMILAR marks — WAVO PUNCH, WAVO TROPICS — which a count of the exact string and its close variations
 // can never retrieve. The 2026-08-12 round scored them 0/8 and 0/9 on BOTH free-tier and clarivate, same
 // day, same engine. That zero is baked in by the product definition, and it costs twice: the two
 // cheapest scenarios cannot detect a recall regression because they are already at the floor, and every

package/driver/register-count.mjs

@@ -301,7 +301,7 @@ function cellSettled(cell, predicate, forms = null) {
 export async function countRegisterHits({
   marks, classes = null, jurisdictions = null, provider, capabilities,
   counter, concurrency = 3, ledgerPath = null, prior = null, now = () => new Date(),
-  variantCap = VARIANT_CAP, unreachable = [],
+  variantCap = VARIANT_CAP, unreachable = [], listed = null,
 }) {
   const { regions: coveredRegions, deferred, worldwide } = resolveRegions(jurisdictions, capabilities);
   // — the office split the plan lane does at compile, done here, because this lane compiles no
@@ -318,6 +318,7 @@ export async function countRegisterHits({
     ? { counted: regions, uncounted: dropped.map((d) => ({ office: d.office, memberId: d.memberId, missing: [...(d.missing ?? [])] })) }
     : null;
   const priorByName = new Map((prior?.marks ?? []).map((m) => [String(m.name), m]));
+  const answeredByListing = listingAnswers(listed, { regions });
   const batchClasses = (Array.isArray(classes) ? classes : []).filter((n) => Number.isInteger(n));
 
   const rows = await runBatched(marks ?? [], concurrency, async (m) => {
@@ -326,11 +327,25 @@ export async function countRegisterHits({
     const scoped = own.length ? own : batchClasses;
     const reused = priorByName.get(name);
     const variants = variantForms(name, { cap: variantCap });
+    // The listing's answers for THIS mark, used only when it was asked over the same classes — see
+    // listingAnswers for why a different scope is a different question.
+    const listedForMark = answeredByListing?.get(name.toLowerCase()) ?? null;
+    const fromListing = listedForMark && sameScope(listedForMark.classes, scoped.length ? scoped : null) ? listedForMark.terms : null;
 
     // ONE PROBE = ONE PROVIDER CALL = ONE LEDGER LINE. Extracted so the aggregate predicate below bills,
     // records and degrades through exactly the same path as the two simple ones — a second copy of this
     // for the variant loop is how the two would come to disagree about what a failure means.
     const probe = async (term, p, { form = null } = {}) => {
+      // ANSWERED BY THE LISTING, and not asked again. The listing ran this exact question — the
+      // provider's exact predicate, this term, these classes, these territories — and its answer carried
+      // the register's total. No call is made, so no receipt line is written; the cell says where its
+      // figure came from.
+      const listedAnswer = p.matchMode === "exact" ? fromListing?.get(String(term).trim().toUpperCase()) : null;
+      if (listedAnswer) {
+        return listedAnswer.approximate === true
+          ? { total: null, approximate: true, floor: listedAnswer.floor ?? null, source: "listing" }
+          : { total: listedAnswer.total, source: "listing" };
+      }
       const started = Date.now();
       let r;
       try { r = await counter(term, p, { classes: scoped, regions }); }
@@ -493,6 +508,46 @@ export async function countRegisterHits({
   };
 }
 
+/**
+ * The listing's answers, by mark and by term, for the count lane to take instead of asking again.
+ *
+ * WHY A LISTING CAN ANSWER A COUNT. The identical and close columns are the provider's exact predicate
+ * over a term, and the knockout's listing (register-records.mjs) asks that same predicate over the same
+ * terms. On a provider whose search answer carries the register's own total, the listing therefore
+ * already holds the count, and asking again is a second bill for a figure in hand.
+ *
+ * ONLY THE SAME QUESTION. A term is taken only when the listing answered it (asked, answered, with a
+ * total or a disclosed approximation), and only when the territories match here and the classes match
+ * per mark (the caller checks those with `sameScope`). A term the listing did not reach — the cap, a
+ * failure — is counted by the count lane as it always was. `containing` is never answered here: the
+ * listing never asks it. Terms are keyed upper-case, because register-variants.mjs asks them upper-case
+ * and name predicates are case-insensitive on every wired provider.
+ *
+ * Null when there is no listing: the caller passes one only on a register that declares
+ * `listingAnswersCount` (pipeline-knockout.mjs). PURE.
+ */
+export function listingAnswers(listed, { regions = [] } = {}) {
+  if (!listed || !Array.isArray(listed.marks)) return null;
+  if (!sameScope(listed.scope?.regions ?? null, regions.length ? regions : null)) return null;
+  const byMark = new Map();
+  for (const m of listed.marks) {
+    const terms = new Map();
+    for (const t of Array.isArray(m?.terms) ? m.terms : []) {
+      if (t?.ok !== true || t.notAsked) continue;
+      if (!Number.isFinite(t.total) && t.approximate !== true) continue;
+      terms.set(String(t.term ?? "").trim().toUpperCase(), t);
+    }
+    byMark.set(String(m?.name ?? "").trim().toLowerCase(), { classes: Array.isArray(m?.classes) ? m.classes : null, terms });
+  }
+  return byMark;
+}
+
+/** Two scopes are the same question when they list the same values in the same order, or are both unset. */
+export function sameScope(a, b) {
+  const norm = (v) => (Array.isArray(v) && v.length ? v.map(String) : null);
+  return JSON.stringify(norm(a)) === JSON.stringify(norm(b));
+}
+
 /** How many marks got at least ONE number. Zero of them means the product did not happen. */
 export function countedMarks(doc) {
   return (doc?.marks ?? []).filter((m) => COUNT_PREDICATES.some((p) => Number.isFinite(m?.counts?.[p.key]?.total))).length;

package/driver/register-digest-record.mjs

@@ -336,7 +336,7 @@ const NEGATIVE_COLUMNS = Object.freeze(["Mark", "Search Term / Variant", "Result
  *
  * 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".
+ * broken qualifier — a missing qualifier is a smaller defect than "HALVER KORPHI — UNDEFINED record".
  */
 export function negativeMarkCell(row) {
   const mark = String(row?.cells?.mark ?? "").trim();

package/driver/register-plan.mjs

@@ -319,7 +319,7 @@ export function variantTermIssue(value) {
   // over marks that may exist. Worse, the disclosure rides on THIS verdict — a null here means no
   // deferred row either, so the nil search shipped as a clean with nothing saying otherwise.
   //
-  // The floor is still doing real work and stays: `DOLPHIN DEVICE` is two words and a perfectly good
+  // The floor is still doing real work and stays: `PANGOLIN DEVICE` is two words and a perfectly good
   // term, and refusing ordinary two-word marks is the failure this arm must not cause. What separates
   // them is not length, it is the ANNOTATION — and an annotation always has a remedy (delete the
   // note, keep the term), which is why hoisting THIS arm is safe where hoisting the length arm above
@@ -1067,8 +1067,8 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
   //     lookup collapses to one entry and hands every term the first romanisation in the manifest.
   //   - the PREVIOUS formKey (NFKD + strip ALL combining marks) was subtler and worse (2026-07-30
   //     review, proven by repro): in most non-Latin scripts a combining mark selects WHICH LETTER
-  //     this is, so mark-distinguished siblings — ティキスラッシュ (TIKI SURASSHU) and ディキスラッシュ
-  //     (DIKI SURASSHU), Thai vowel signs, Devanagari matras, Arabic diacritics — keyed identically
+  //     this is, so mark-distinguished siblings — ワボスラッシュ (WABO SURASSHU) and ワホスラッシュ
+  //     (WAHO SURASSHU), Thai vowel signs, Devanagari matras, Arabic diacritics — keyed identically
   //     and a variant silently received its SIBLING's romanisation. The provider then executed a
   //     look-alike query and recorded state:enumerated while the dictated form was never searched
   //     anywhere: the exact silent-wrong-query false-clean class this carriage fix exists to kill,
@@ -1137,8 +1137,8 @@ export function compileRegisterPlan({ manifest, job, form = null, skillVersion =
   };
 
   // ── A1, fixed at the EMITTER (the freeze-lint below must never refuse the compiler's own output) ──
-  // The 2026-07-28 plan carried {predicate:"exact", term:"TIKI*"} ×4: wildcard-shaped VARIANT values
-  // (`TIKI*`, `*TIKI`, `SLUSH*`, `*SLUSH`) paired with the hardcoded exact — dispatched literally,
+  // The 2026-07-28 plan carried {predicate:"exact", term:"WAVO*"} ×4: wildcard-shaped VARIANT values
+  // (`WAVO*`, `*WAVO`, `SLUSH*`, `*SLUSH`) paired with the hardcoded exact — dispatched literally,
   // returned 0, shipped as schema-level confident cleans. A manifest value with an ANCHORED star is a
   // wildcard pattern and compiles to the wildcard predicate (whose per-anchor capability check then
   // stamps `unsupported` on a provider that lacks that anchor — the honest deferred row, decided by the

package/driver/register-records.mjs

@@ -247,6 +247,7 @@ export async function listRegisterRecords({
             ts: now().toISOString(), stage: "records", mark: name, term: t.term, basis: t.basis,
             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 ? {} : { cause: String(r?.reason ?? "unknown").slice(0, 300) }),
           }) + "\n");
         } catch { /* receipts are best-effort, never fatal */ }
@@ -256,6 +257,9 @@ export async function listRegisterRecords({
         // How many the register HOLDS under this term, where it said. `fetched` under `total` is the
         // truncation, and it is stated rather than left for a reader to notice.
         total: Number.isFinite(r?.total) ? r.total : null,
+        // 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 } : {}),
         ...(ok ? {} : { reason: String(r?.reason ?? "the filings could not be fetched").slice(0, 300) }),
       };
     });
@@ -269,7 +273,12 @@ export async function listRegisterRecords({
       // The three numbers a reader needs to trust the list: how many are here, how many the register
       // said there are under the listed terms, and whether the cap cut it.
       fetched: records.length,
-      available: termRows.reduce((n, t) => (Number.isFinite(t.total) ? n + t.total : n), 0),
+      // NO SUM WHEN ANY ANSWERED TERM IS APPROXIMATE. An approximation carries a floor and no number, so a
+      // sum around it counts only the exact terms: a name the register answered as more than 10,000 read
+      // "out of 800 hits" beside its two close forms. With no honest total none is stated (recordsLine
+      // drops the clause for a non-number), and the counts line still carries the approximation.
+      available: termRows.some((t) => t.ok && t.approximate === true) ? null
+        : termRows.reduce((n, t) => (Number.isFinite(t.total) ? n + t.total : n), 0),
       capped: capped || records.length >= markCap,
       cap: markCap,
       // — which registers this listing covers, present only when one was dropped. Per-mark for the

package/driver/registry-fidelity.mjs

@@ -467,7 +467,7 @@ export const REC = {
   isLive: (r) => r.statusClass === "live" || /\b(valid|live|registered)\b/i.test(String(r.onomaticsStatus ?? r.corsearchStatusCode ?? "")),
   statusStr: (r) => String(r.statusText ?? r.onomaticsStatus ?? r.corsearchStatusCode ?? r.statusClass ?? ""),
   // doc-31 step 4: the proprietor/applicant name as the record holds it — the AUTHORITATIVE owner display, so a
-  // model-typed/​invented variant ("Lo.Li. Pharma International" for a record that says "Lo.Li. Pharma S.r.l.")
+  // model-typed/​invented variant ("Be.Ma. Pharma International" for a record that says "Be.Ma. Pharma S.r.l.")
   // never becomes the card's owner. Provider-blind: every normalizer writes `owner` (legacy: ownerName/proprietor).
   owner: (r) => String(r.owner ?? r.ownerName ?? r.proprietor ?? "").trim(),
   // — the owner's name in its ORIGINAL script, when the record draws that distinction. Its presence
@@ -658,7 +658,7 @@ export function joinEvidenceStatus(findings, recordsByUri = new Map(), fetchFail
         // weight, and it happened silently over the seat's correct answer on four of five rows of one
         // delivered report: classifyUseSource needs the full de-suffixed owner token as a contiguous
         // substring of the host, and real brand domains are shorter than corporate names
-        // ("propperdocs" is not inside "propperai"). What survives exactly: the register-mirror
+        // ("acmedocs" is not inside "acmeai"). What survives exactly: the register-mirror
         // demotion's precedence — attested OR host-detected, a mirror wins over everything, because
         // that direction can only weaken the evidence.
         const host = /^https?:\/\//i.test(f.use_check.source) ? classifyUseSource(f.use_check.source, f.owner?.name) : null;
@@ -1028,8 +1028,8 @@ export function bindFindingsToRecords(findings, recordsByUri) {
     }
     // ── the owner's name: one asserted fact, one presentation choice ──────────────────────────
     //
-    // doc-31 step 4 binds owner.name from the record so a model-typed variant ("Lo.Li. Pharma
-    // International" for a record that says "Lo.Li. Pharma S.r.l.") never becomes the card's owner. That
+    // doc-31 step 4 binds owner.name from the record so a model-typed variant ("Be.Ma. Pharma
+    // International" for a record that says "Be.Ma. Pharma S.r.l.") never becomes the card's owner. That
     // still holds, and the test that pins it is unchanged.
     //
     // What it got wrong is the CJK case. The provider's Latin field is a ROMANISATION there — for a

package/driver/repair-composers.mjs

@@ -226,7 +226,7 @@ export const REPAIR_COMPOSERS = [
         // 2026-07-04 (the VENZY corrective thrash): three attempts died inventing three different keys
         // while trying to EXPRESS a hold. The contract is closed and every correction is expressible
         // inside it — say so.
-        `THE FINDINGS CONTRACT IS CLOSED — MINIMAL CHANGE ONLY: start from the finding objects as you last sent them and change the smallest set of existing fields the flags require; NEVER invent a key, a state, or an enum value (any unknown key fails the file and, repeated, fails the WHOLE RUN). Every correction the reviewer can ask for is expressible with existing fields: an unsourced/confabulated attribution ⇒ that finding gets "disposition":"withdrawn" + "withdrawn_reason", OR its owner/prose is re-attributed to what the sources actually support — an identity that needs the applicant's confirmation is stated in the finding's prose/impact text, NEVER as a new field or note-type; use_check.quality is EXACTLY one of owner-site | independent | register-mirror or omitted; context_notes entries are EXACTLY {"type","mark","owner","context"}. RE-TYPING A DISPOSITION CARRIES ITS FIELDS WITH IT (#242) — this is the one case where a minimal edit MUST add a key, and these are the only keys it may add: re-typing a finding TO "off-field" also sets "off_field_ground" (EXACTLY "different-field" — only where that finding's own goods_proximity meter reads "low" — or "no-material-risk"), and re-typing AWAY from "off-field" REMOVES it; any finding that is not "withdrawn" keeps a non-empty "legal_position" and "practical_position", so a re-type that lands on a finding missing either must write both. Nothing else may be added.`,
+        `THE FINDINGS CONTRACT IS CLOSED — MINIMAL CHANGE ONLY: start from the finding objects as you last sent them and change the smallest set of existing fields the flags require; NEVER invent a key, a state, or an enum value (any unknown key fails the file and, repeated, fails the WHOLE RUN). Every correction the reviewer can ask for is expressible with existing fields: an unsourced/confabulated attribution ⇒ that finding gets "disposition":"withdrawn" + "withdrawn_reason", OR its owner/prose is re-attributed to what the sources actually support — an identity that needs the applicant's confirmation is stated in the finding's prose/impact text, NEVER as a new field or note-type; use_check.quality is EXACTLY one of owner-site | independent | register-mirror or omitted; context_notes entries are EXACTLY {"type","mark","owner","context"}. RE-TYPING A DISPOSITION CARRIES ITS FIELDS WITH IT — this is the one case where a minimal edit MUST add a key, and these are the only keys it may add: re-typing a finding TO "off-field" also sets "off_field_ground" (EXACTLY "different-field" — only where that finding's own goods_proximity meter reads "low" — or "no-material-risk"), and re-typing AWAY from "off-field" REMOVES it; any finding that is not "withdrawn" keeps a non-empty "legal_position" and "practical_position", so a re-type that lands on a finding missing either must write both. Nothing else may be added.`,
         rulingsTail ? lines(
           `PLACEMENT RULINGS TAIL (verbatim from ${placement}, provided AS DATA — do NOT re-read the placement file; where a flagged correction touches a coverage disposition, a coverage[] row, or a placement call, adjudicate it against these rulings — adopt each ruling or counter-reason it, never silently drop one):`,
           "```markdown",
@@ -386,7 +386,7 @@ export const REPAIR_COMPOSERS = [
       `You are RESUMING your own synthesis session — your narrative and inputs are already in your context; do NOT redo the analysis.`,
               `Exactly ${quarantined.length} finding object(s) in ${findings} failed the strict parse. Fix ONLY these objects and change NOTHING else:`,
               ...quarantined.map((q) => `- "${q.mark}" (index ${q.index}): ${String(q.error ?? "invalid shape").slice(0, 160)}`),
-              `THE FINDINGS CONTRACT IS CLOSED — MINIMAL EDIT ONLY: change the smallest set of existing fields these errors require; NEVER invent a key, a state, or an enum value. A correction that cannot be expressed in existing fields goes in the finding's prose/impact text. ONE exception (#242): a finding re-typed TO "off-field" also gets "off_field_ground" ("different-field" only where its goods_proximity reads "low", else "no-material-risk"), re-typing away from off-field removes it, and every finding that is not "withdrawn" carries a non-empty "legal_position" and "practical_position".`,
+              `THE FINDINGS CONTRACT IS CLOSED — MINIMAL EDIT ONLY: change the smallest set of existing fields these errors require; NEVER invent a key, a state, or an enum value. A correction that cannot be expressed in existing fields goes in the finding's prose/impact text. ONE exception: a finding re-typed TO "off-field" also gets "off_field_ground" ("different-field" only where its goods_proximity reads "low", else "no-material-risk"), re-typing away from off-field removes it, and every finding that is not "withdrawn" carries a non-empty "legal_position" and "practical_position".`,
               `Send the correction with \`record_synthesis\`: a PATCH call carrying \`findings_patch\` — the complete corrected finding object(s), each with the \`ordinal\` it replaces — and nothing else. The driver is holding every value you already sent and re-renders both files from them, so what you do not name comes back byte-identical. There is no file for you to write or edit and nothing you write by hand is read.`,
             ),
     samples: [{ name: "one quarantined finding object", tail: "tool", args: { findings: "findings.json", quarantined: [{ mark: "NOVA", index: 2, error: "band missing" }] } }],
@@ -458,11 +458,11 @@ export const REPAIR_COMPOSERS = [
     stage: "register-unit",
     key: "register-unit:plan-join-fresh",
     route: "freshMessage",
-    compose: ({ axis, registerPlan, bandPath }) => lines(
-        `Execute the FROZEN register plan for axis "${axis}": call register_execute_plan ONCE with {"plan_path": "${registerPlan}", "axis": "${axis}", "output_path": "${bandPath}"} — the tool runs this axis's dictated entries and MERGES the band itself (existing blocks survive; the missing dictated blocks land, qids stamped). Do NOT run the entries manually, do NOT edit the band yourself, author NO clearance verdict.`,
+    compose: ({ axis, registerPlan, bandPath, entries = [] }) => lines(
+        `Execute the FROZEN register plan for axis "${axis}": call register_execute_plan ONCE with {"plan_path": "${registerPlan}", "axis": "${axis}", "output_path": "${bandPath}"${entries.length ? `, "qids": ${JSON.stringify(entries.map((e) => e.qid))}` : ""}} — the tool runs ${entries.length ? "ONLY those dictated entries, the ones with no band block yet," : "this axis's dictated entries"} and MERGES the band itself (every other block stays as it is; the missing dictated blocks land, qids stamped). Do NOT run the entries manually, do NOT edit the band yourself, author NO clearance verdict.`,
         `Return ONLY: the band path + the tool's summary line.`,
       ),
-    samples: [{ name: "a fresh plan execution", tail: "tool", args: { axis: "eu", registerPlan: "register-plan.json", bandPath: "bands/eu.md" } }],
+    samples: [{ name: "a fresh plan execution", tail: "tool", args: { axis: "eu", registerPlan: "register-plan.json", bandPath: "bands/eu.md", entries: [{ qid: "q1" }] } }],
   },
   {
     trigger: "plan-join",
@@ -472,7 +472,7 @@ export const REPAIR_COMPOSERS = [
         `You are RESUMING your own register-unit session (axis "${axis}"). Your unit digest stands — do NOT redo it.`,
         `These DICTATED plan entries have no band block yet:`,
         ...entries.map((e) => `- qid "${e.qid}": ${e.predicate} ${e.terms ? `names ${JSON.stringify(e.terms)}` : `"${e.term}"`} · nice_classes ${JSON.stringify(e.nice_classes)}${e.regions?.length ? ` · regions ${JSON.stringify(e.regions)}` : ""} · expected: ${e.expected_kind}`),
-        `Close them by calling register_execute_plan ONCE with {"plan_path": "${registerPlan}", "axis": "${axis}", "output_path": "${bandPath}"} — the tool re-runs this axis's dictated entries and MERGES the band itself (your judgment blocks survive; the missing dictated blocks land, qids stamped). Do NOT run the entries manually or edit the band yourself.`,
+        `Close them by calling register_execute_plan ONCE with {"plan_path": "${registerPlan}", "axis": "${axis}", "output_path": "${bandPath}", "qids": ${JSON.stringify(entries.map((e) => e.qid))}} — the tool runs ONLY those entries and MERGES the band itself (your judgment blocks and every other block stay as they are; the missing dictated blocks land, qids stamped). Do NOT run the entries manually or edit the band yourself, and do not call it without qids: that re-runs every entry on the axis.`,
         `Return ONLY: the band path + the tool's summary line.`,
       ),
     samples: [{ name: "one dictated entry with no band block", tail: "tool", args: { axis: "eu", registerPlan: "register-plan.json", bandPath: "bands/eu.md", entries: [{ qid: "q1", predicate: "identical", term: "NOVA", nice_classes: [9], expected_kind: "exact" }] } }],