clearotron 0.3.2-beta.11 → 0.3.2-beta.13

package/driver/progress.mjs

@@ -97,6 +97,30 @@ export function stepForStage(rawStageKey) {
   return { index, label: DISPLAY_STEPS[index], n: index + 1, total: DISPLAY_STEPS.length };
 }
 
+/**
+ * THE STAGE A LIVE RUN IS IN NOW, for the card and the row a person watches (owner, 2026-09-19).
+ *
+ * status.json keeps two readings. The step fields hold the furthest display step ever reached, for a
+ * stepper that never runs backwards. `lastStage` is the stage the run ENTERED last, written at the one
+ * choke point every dispatch passes, corrective re-entries included. The card named the first, so a run
+ * sent back into synthesis by a correction pass went on reading "Case law & refutation" (measured on a
+ * beta, 2026-09-18). This names the stage in hand, a step back included, with its own step number.
+ *
+ * `currentStep` FIRST, where the run wrote one: the step it is in now, in the stepper's own words, moved by
+ * every transition in either direction and left in place through a stage with no display step. A status
+ * written before that field existed falls back to mapping `lastStage`, and one with neither keeps the
+ * furthest step, which is the best reading there is. PURE.
+ */
+export function stageNow(status) {
+  const c = status?.currentStep;
+  if (c && typeof c.label === "string" && c.label.trim())
+    return { step: c.label, stepN: Number.isFinite(c.n) ? c.n : null, stepTotal: Number.isFinite(c.total) ? c.total : null };
+  const now = stepForStage(status?.lastStage);
+  return now
+    ? { step: now.label, stepN: now.n, stepTotal: now.total }
+    : { step: status?.stepLabel ?? null, stepN: status?.stepN ?? null, stepTotal: status?.stepTotal ?? null };
+}
+
 // Lifecycle honesty (charter P1 §4): the status patch a TERMINAL delivered write must carry. Nothing runs
 // after the report: delivery is a packet and publish is code, so no
 // recordTransition ever advances the stepper past "Drafting the report" — a delivered run (with
@@ -386,6 +410,7 @@ export function seedRunStatus(ctx, { resume = false } = {}) {
     // — the identity is the SHARED rule, not this stepper's. See identitySeed.
     ...identitySeed(),
     stepIndex: first.index, stepLabel: first.label, stepN: first.n, stepTotal: first.total,
+    currentStep: currentStepOf(first),
     lastStage: null,
     verdict: null,
     url: null,
@@ -407,15 +432,26 @@ export function seedRunStatus(ctx, { resume = false } = {}) {
 // so for the whole of any of them every surface went on naming the PREVIOUS stage, which is the same
 // defect as a stale step wearing a different field. The step fields are still withheld — that part of
 // the early return was right, and an unmapped stage must never touch the displayed step.
+//
+// `currentStep` IS THE STEP THE RUN IS IN NOW, and it moves both ways. The step fields above keep the
+// furthest step reached (writeRunStatus), so a corrective pass that re-enters synthesis after case law
+// left them reading case law while `lastStage` read synthesis (measured 2026-09-18). `lastStage` is the
+// raw key; this is the same moment in the stepper's own words, for a surface that shows where the run is.
+// A stage with no display step leaves it where it was: those stages run inside the step already shown.
 export function recordTransition(ctx, rawStageKey) {
   const step = stepForStage(rawStageKey);
   writeRunStatus(ctx, {
-    ...(step ? { stepIndex: step.index, stepLabel: step.label, stepN: step.n, stepTotal: step.total } : {}),
+    ...(step ? { stepIndex: step.index, stepLabel: step.label, stepN: step.n, stepTotal: step.total, currentStep: currentStepOf(step) } : {}),
     lastStage: rawStageKey,
   });
   rollupStatus(ctx?.run?.studioRoot);
 }
 
+/** The stepper's own words for one step, as `currentStep` carries it. PURE. */
+function currentStepOf(step) {
+  return { index: step.index, label: step.label, n: step.n, total: step.total };
+}
+
 // ---- STATUS.md rollup --------------------------------------------------------------------------------
 // The archive lives UNDER studioRoot (studioRoot/archive/...), so a recursive walk of studioRoot finds
 // both in-flight and delivered/failed runs. Cap depth (status.json only sits at the run-dir level) and

package/driver/publish/render-knockout.mjs

@@ -62,6 +62,7 @@ import { EXPORT_TOGGLE, exportPopover, EXPORT_MENU_JS } from './report-topbar.mj
 // which is the thing providers/_shared/screen.mjs exists to prevent.
 import { makeClassifyStatus, isAllClass } from '../../providers/_shared/screen.mjs';
 import { saysSomethingNew } from '../../shared/says-something-new.mjs';
+import { isNextStepHeading } from '../knockout-next-step.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -1513,21 +1514,25 @@ function koScale(framework, band) {
 // It MOVES, it is not copied: `splitOutcome` returns the assessment without it, and the fold renders
 // that remainder, so the words appear once.
 //
+// A RECORD WRITTEN SINCE 2026-09-19 NEVER REACHES THIS WITH ONE: the pipeline removes a next-step section
+// before it writes the record (`knockout-next-step.mjs`), and the heading test below is that module's, so
+// the two cannot come to disagree about what a next step is. What still draws the section is a record
+// written before then, re-rendered.
+//
 // THE HEADING IS THE MODEL'S OWN, so this hoists only the LAST block of the assessment. The assessing
-// skill fixes no heading vocabulary — it asks for sub-headers "where the content divides" and for the
-// read to close on what to do with the name, and the wording is written fresh each run. Matching a list
-// of phrases anywhere in the document would let a mark whose read happens to argue under "Recommendation"
-// in the MIDDLE have that middle lifted to the bottom, handing the client the engine's argument in an
-// order the engine did not write, with nothing going red. A trailing block is the one position where a
-// move cannot reorder what is left. So the phrase list only decides whether the last block is the
-// outcome; anything earlier stays where it was written, and the page renders the assessment whole.
-const OUTCOME_HEADING_RE = /^#{1,6}\s*(?:what to do with it|what happens next|next steps?|recommendations?)\b\s*$/i;
+// skill fixes no heading vocabulary — it asks for sub-headers "where the content divides", and the
+// wording is written fresh each run. Matching a list of phrases anywhere in the document would let a
+// mark whose read happens to argue under "Recommendation" in the MIDDLE have that middle lifted to the
+// bottom, handing the client the engine's argument in an order the engine did not write, with nothing
+// going red. A trailing block is the one position where a move cannot reorder what is left. So the
+// phrase list only decides whether the last block is the outcome; anything earlier stays where it was
+// written, and the page renders the assessment whole.
 export function splitOutcome(assessment) {
   const whole = String(assessment ?? '').trim();
   const lines = whole.split('\n');
   const heads = lines.map((l, i) => [l.trim(), i]).filter(([l]) => /^#{1,6}\s/.test(l));
   const last = heads[heads.length - 1];
-  if (!last || !OUTCOME_HEADING_RE.test(last[0])) return { body: whole, outcome: '' };
+  if (!last || !isNextStepHeading(last[0])) return { body: whole, outcome: '' };
   const outcome = lines.slice(last[1] + 1).join('\n').trim();
   if (!outcome) return { body: whole, outcome: '' };
   return { body: lines.slice(0, last[1]).join('\n').trim(), outcome };

package/driver/publish/render.mjs

@@ -90,7 +90,7 @@ let SENIOR_RIGHTS = new Map();
 let DISPOSITION_MODE = false;
 // — per-render flag: true when the record declares the v6 findings contract, which is the one that
 // guarantees a position on every negative and a TYPED off-field ground. Gates the grouped
-// reasoned-negative rendering; false ⇒ the pre- section, byte-identical, for every archived run.
+// reasoned-negative rendering; false ⇒ the pre-change section, byte-identical, for every archived run.
 let NEGATIVES_GROUPED = false;
 // doc 50 — the run's FROZEN framework manifest (opts.framework, from _driver/framework.json). When
 // present the report speaks ITS band words: chips/one-liners read f.band, the gauge ticks show its
@@ -1825,7 +1825,7 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   // too. It never did — the grouping's own note promises "each member is a <details> whose body is the
   // same fullDetail block the compact card carries", and until now that was untrue of the one thing v6
   // guarantees on every negative. Suppressing them there would take a conditional whose only job is
-  // reproducing the pre- shape, which is the legacy code path this program forbids.
+  // reproducing the pre-change shape, which is the legacy code path this program forbids.
   //
   // Absent fields ⇒ both helpers return '' ⇒ zero bytes, and the interpolation is attached to the
   // template's opening so it leaves no whitespace-only line (review 2026-07-31, problem 8).
@@ -1859,7 +1859,7 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   //
   // WHERE THERE IS NO PROSE THE TYPED PAIR IS STILL THE ACCOUNT, and that is most of the surfaces
   // fullDetail feeds: a structured-only finding (no card file), a reasoned-negative row, a compact
-  // card whose report-card stage produced nothing. 's promise that a negative's drawer carries its
+  // card whose report-card stage produced nothing. The promise that a negative's drawer carries its
   // positions is untouched — a negative has no Full-detail prose to duplicate.
   //
   // manageableLine is NOT gated: the manageable category is a closed code-owned vocabulary the prose has
@@ -1988,7 +1988,7 @@ function manageableLine(f) {
 //
 // TRIM-TO-EMPTY IS LOAD-BEARING AND IS PRESERVED VERBATIM. `foldClause` returned '' for null, undefined,
 // '' and whitespace-only input, and that empty string is what makes `clause(f.net) || card?.meta?.one ||
-// oneFallback(...)` fall through to exactly the pre- value on an archived run, which carries no
+// oneFallback(...)` fall through to exactly the pre-change value on an archived run, which carries no
 // `net`. Deleting the function without keeping that behaviour would move every archived card whose
 // `net` key exists but is blank. `clause` is `foldClause` with the budget arm removed and nothing else.
 const clause = (value) => String(value ?? '').trim();
@@ -2314,7 +2314,7 @@ function contextNotesBlock(notes = []) {
 }
 
 // charter ruling 1 (2026-07-30, name-led): the masthead depth strip LEADS with the product's registry
-// name in bold — the same name 's read pills speak, never a rung on our ladder — then the coverage
+// name in bold — the same name the read pills speak, never a rung on our ladder — then the coverage
 // clauses (what this search covers / omits, from the run's frozen components via productCoverageNote).
 // The seam is the LAST " — ": a registry name may itself carry one ("Preliminary clearance — register
 // only") while the coverage clauses never do (they join on ";" and ","). A note with no seam at all
@@ -2323,7 +2323,7 @@ function contextNotesBlock(notes = []) {
 /**
  * THE HERO VERDICT CAPTION, folded to its first sentence.
  *
- * 's design ruling: above any fold, only a statement, a labelled row, a count or a one-line card —
+ * The design ruling: above any fold, only a statement, a labelled row, a count or a one-line card —
  * "prose never appears until someone opens something, and once opened nothing is ever cut". The finding
  * cards were moved onto that rule by `cf8dd43`; the hero caption was named in the same ruling and left
  * behind, and this is the bullet that PR recorded as still owed.

package/driver/record-discard.mjs

@@ -5,7 +5,7 @@
 //
 // ── why this exists ──────────────────────────────────────────────────────────────────────────────────
 //
-// The shipped trace (/) asked ONE pass to answer a question that spans two moments that never
+// The shipped trace asked ONE pass to answer a question that spans two moments that never
 // coexist. A record discarded at screening is gone by the time `findings.json` is written; the findings
 // do not exist at the moment the record is discarded. Whichever end a single pass runs at, it guesses
 // about the other — and `deriveRecordCarry` ran inside `register-digest`, which is BEFORE `synthesis`

package/driver/register-availability.mjs

@@ -41,7 +41,7 @@
 // CORRECTED 2026-08-11 — THIS PARAGRAPH USED TO SAY "one qid per office … which is the shape
 // joinPlanToBands already has", AND THAT WAS FALSE ABOUT THE COMPILER IT DOCUMENTS. There is no
 // per-office qid. compileRegisterPlan narrows ONE shared `regions` array and hands it to every entry
-// (register-plan.mjs:779 compileRegisterPlan); the unreachable office produces no entry, so no qid, so no band block, so
+// (register-plan.mjs:805 compileRegisterPlan); the unreachable office produces no entry, so no qid, so no band block, so
 // nothing ever reaches joinPlanToBands' deferred bucket — whose only source is a block stamped
 // `error:true && deferred:true` (register-plan.mjs:1317 extendRegisterPlan).
 //

package/driver/register-count.mjs

@@ -447,7 +447,7 @@ export async function countRegisterHits({
       counts,
       // — which registers these figures cover, present ONLY when one was dropped. countLine renders
       // it; the scope block below records it. Both, deliberately: `scope.deferredJurisdictions` has sat
-      // on this artifact since it was written and NOTHING reads it, which is the same shape as 's
+      // on this artifact since it was written and NOTHING reads it, which is the same shape as
       // `deferred_coverage` riding the plan with no consumer and shipping a false clean. A field a
       // reader never sees is not a disclosure, so this one lands on the rendered line first.
       ...(officeScope ? { officeScope } : {}),

package/driver/register-digest-record.mjs

@@ -366,7 +366,7 @@ export function negativeMarkCell(row) {
 const MIN_JUDGED_ROWS = 1;
 
 /** A pipe row, cells escaped so a value carrying `|` cannot open a column. */
-const row = (cells) => `| ${cells.map((c) => str(c).replace(/\|/g, "\\|").replace(/\n+/g, " ") || "—").join(" | ")} |`;
+const row = (cells) => `| ${cells.map((c) => str(c).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n+/g, " ") || "—").join(" | ")} |`;
 const table = (columns, rows) => [row(columns), `|${columns.map(() => "---").join("|")}|`, ...rows.map(row)].join("\n");
 
 /**

package/driver/register-plan.mjs

@@ -705,12 +705,7 @@ export function excludeHouseElement(manifest, house) {
 
   const lcEl = element.toLowerCase();
   const lcWords = words.map((w) => w.toLowerCase());
-  // A word of the remainder, by word boundary rather than by containment: `includes` would count the
-  // remainder word "on" inside an unrelated mutation and keep a query this exists to drop.
-  const namesRemainder = (v) => {
-    const t = String(v ?? "").toLowerCase();
-    return lcWords.some((w) => new RegExp(`(^|[^\\p{L}\\p{N}])${w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^\\p{L}\\p{N}]|$)`, "u").test(t));
-  };
+  const namesRemainder = (v) => namesAnyWord(v, lcWords);
 
   // THE DOMINANT WORD OF THE REMAINDER: longest, ties broken by the LAST of them. The lawyer's own
   // phrasing was "the last word alone", and on the matter that produced this the two agree; longest is
@@ -738,11 +733,75 @@ export function excludeHouseElement(manifest, house) {
   // REQUIREMENT 3: the element is still checked ONCE, as a confirmation of the client's own live
   // registrations rather than as a conflict search — so the exclusion is evidenced on the report by a
   // query that ran, not by a sentence saying one would have.
+  // The remainder rides on it so a writer AFTER the compile can apply the same rule (`houseElementOf`).
   const confirmation = { axis: "incumbent-class", predicate: "owner", term: element,
-    expected_kind: "enumerate", provenance: "mark", house_element_confirmation: true };
+    expected_kind: "enumerate", provenance: "mark", house_element_confirmation: true,
+    house_element_remainder: remainder };
   return { manifest: next, confirmation, refused: null };
 }
 
+/**
+ * Does `text` carry any of `words` (lower-case) as a word of its own? By word boundary rather than by
+ * containment: `includes` would count the remainder word "on" inside an unrelated mutation.
+ */
+function namesAnyWord(text, words) {
+  const t = String(text ?? "").toLowerCase();
+  return words.some((w) => new RegExp(`(^|[^\\p{L}\\p{N}])${w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^\\p{L}\\p{N}]|$)`, "u").test(t));
+}
+
+/**
+ * The house element a plan was compiled without, read off the plan itself, or null.
+ *
+ * WHY THE PLAN CARRIES IT. The compile is not the only writer. After it, the common-law cross-check,
+ * the recall lane, the frame reopen and the jurisdiction candidates fold entries in, and the register
+ * session proposes its own. On the first live run that proposed an exclusion (2026-09-19) the compile
+ * dropped the element and two later writers put it straight back: a contains query from the cross-check
+ * and an exact query the register session proposed, both on the bare element. Those writers hold the
+ * plan and nothing else, so the plan is where the exclusion has to be readable. Its confirmation row
+ * names the element, and the remainder rides beside it because the rule needs both.
+ */
+export function houseElementOf(plan) {
+  const c = (plan?.entries ?? []).find((e) => e?.house_element_confirmation === true);
+  const element = String(c?.term ?? "").trim();
+  if (!element) return null;
+  const remainder = String(c?.house_element_remainder ?? "").trim().toLowerCase();
+  return { element, remainderWords: remainder.split(/\s+/).filter(Boolean) };
+}
+
+/**
+ * Is this term a search on the excluded house element? The compile's own rule (`excludeHouseElement`
+ * keeps a variant only when it names a word of the remainder), applied to a term that arrives after
+ * the compile: a term carrying the element and no word of the remainder is a search on the element,
+ * whether it is the bare element, the element with a suffix, or the element beside other words. A term
+ * carrying a word of the remainder, like the whole mark, is kept, as the compile keeps it.
+ *
+ * A plan frozen before the remainder was recorded knows the element only, and then only the bare
+ * element counts: "carries no word of the remainder" cannot be decided without the remainder.
+ */
+export function isHouseElementTerm(term, house) {
+  if (!house) return false;
+  const t = String(term ?? "").trim().toLowerCase();
+  const el = house.element.toLowerCase();
+  if (t === el || (norm(el) !== "" && norm(t) === norm(el) && formKey(t) === formKey(el))) return true;
+  if (!house.remainderWords.length) return false;
+  const carries = t.includes(el) || (norm(el) !== "" && norm(t).includes(norm(el)));
+  return carries && !namesAnyWord(t, house.remainderWords);
+}
+
+/**
+ * The entry without its house-element terms, or null when none is left. An owner sweep is not mark
+ * text and comes back untouched: the one owner query on the element is the confirmation itself. PURE.
+ */
+export function withoutHouseElementTerms(entry, house) {
+  if (!house || !entry || entry.predicate === "owner") return entry;
+  if (Array.isArray(entry.terms)) {
+    const kept = entry.terms.filter((t) => !isHouseElementTerm(t, house));
+    if (!kept.length) return null;
+    return kept.length === entry.terms.length ? entry : { ...entry, terms: kept };
+  }
+  return isHouseElementTerm(entry.term, house) ? null : entry;
+}
+
 export function compileRegisterPlan({ manifest, job, form = null, skillVersion = "", capabilities = null, unavailableOffices = [], houseElement = null }) {
   // ── AN EXCLUDED ELEMENT'S FORM BAND MUST BE UNREACHABLE, NOT MERELY UNASKED-FOR ─────────────────
   //
@@ -1495,10 +1554,13 @@ export function entryQuestionKey(entry, plan) {
  * an absence, and an absence reported as success is the failure this whole issue is about. Every
  * caller writes them somewhere a reader will meet them.
  *
- * Returns { plan, added: [qid], refused: [{qid, term, issue}] }.
+ * Returns { plan, added: [qid], refused: [{qid, term, issue}], excluded: [qid] } — `excluded` are rows on
+ * the house element the compile set aside, left out quietly (see houseElementOf).
  */
 export function foldSupplementalEntries(plan, entries) {
   const have = new Set(plan.entries.map((e) => e.qid));
+  const house = houseElementOf(plan);
+  const excluded = [];
   // — first qid wins, so the refusal names the row already IN the plan rather than a later
   // arrival. The compiler's own rows are in here too: a supplemental re-proposal of a compiler slice
   // is the case that actually fired on the round in evidence.
@@ -1530,8 +1592,9 @@ export function foldSupplementalEntries(plan, entries) {
   // one identity, which is the fault. Keyed on the qid alone this refused the harmless case too, and
   // the suite's own arm said so.
   const inBatch = new Map();   // qid -> the term that claimed it
-  for (const e of entries ?? []) {
-    if (!e || typeof e.qid !== "string" || !e.qid) continue;
+  for (const offered of entries ?? []) {
+    if (!offered || typeof offered.qid !== "string" || !offered.qid) continue;
+    let e = offered;
     const eTerm = String(e.term ?? e.terms?.[0] ?? "");
     if (inBatch.has(e.qid) && inBatch.get(e.qid) === eTerm) continue;   // the same row twice — one refusal
     if (inBatch.has(e.qid)) {
@@ -1546,6 +1609,12 @@ export function foldSupplementalEntries(plan, entries) {
     inBatch.set(e.qid, eTerm);
     if (have.has(e.qid)) continue;   // already in the PLAN — a re-proposal, expected and quiet
     have.add(e.qid);            // a refused qid is claimed too — the same row twice is one refusal
+    // THE CLIENT'S OWN ELEMENT, SET ASIDE BY THE COMPILE, IS NOT FOLDED BACK IN (see houseElementOf).
+    // QUIET, NOT REFUSED: a refused row renders to the client as an OPEN ask, and this is no unanswered
+    // question. The plan's confirmation row answers it and the report states the exclusion.
+    const kept = withoutHouseElementTerms(e, house);
+    if (!kept) { excluded.push(e.qid); continue; }
+    e = kept;
     const issues = entryTermIssues(e);
     if (issues.length) {
       refused.push({ qid: e.qid, term: String(e.term ?? e.terms?.[0] ?? ""),
@@ -1570,11 +1639,12 @@ export function foldSupplementalEntries(plan, entries) {
     if (key && e.unsupported !== true) asked.set(key, e.qid);   // dedupes the batch too, on the question
     added.push(e);
   }
-  if (!added.length) return { plan, added: [], refused };
+  if (!added.length) return { plan, added: [], refused, excluded };
   return {
     plan: { ...plan, plan_version: (plan.plan_version ?? 1) + 1, entries: [...plan.entries, ...added] },
     added: added.map((e) => e.qid),
     refused,
+    excluded,
   };
 }
 

package/driver/report-card-record.mjs

@@ -117,9 +117,9 @@ export function findingsDocFor(runDir, ordinal) {
 // the record and under what number. publish/index.mjs quotes the correct shape verbatim in a comment of
 // its own, which is what makes the divergence provable rather than a matter of taste.
 //
-// IT SHIPPED BECAUSE THE CONVERSION WAS NEVER CHECKED AGAINST THE ARTIFACT. asked for exactly that
+// IT SHIPPED BECAUSE THE CONVERSION WAS NEVER CHECKED AGAINST THE ARTIFACT. The issue asked for exactly that
 // check — "recompose the bullet for every card in demo and assert byte-equality with the
-// delivered report.md" — and writing it is what caught this. The guard now lives beside 's, and
+// delivered report.md" — and writing it is what caught this. The guard now lives beside the code it checks, and
 // this is the argument for building the guard an issue asks for even when the code already looks done.
 //
 // THE NUMBER comes off the URI's last segment: `/mark/eu/018575624` → `018575624`. That is a parse, and

package/driver/result-noun-fields.mjs

@@ -95,7 +95,9 @@ export const RESULT_NOUN_FIELDS = Object.freeze([
   // writing site like the other two — it is a returned CLASSIFICATION of a checkout, not a field named
   // for a result whose value is what a call returned, so the verdict is unchanged.
   { file: "driver/engine-build.mjs", noun: "outcome", sites: 3, atWriteSite: 0, verdict: "out-of-scope" },
-  { file: "driver/engine/mcp/supplemental.mjs", noun: "executed", sites: 2, atWriteSite: 0, verdict: "out-of-scope" },
+  // Read at the writing site: the third is the reply when every proposal was the house element the
+  // compile set aside — `executed: false` because nothing ran, the same statement as the error reply.
+  { file: "driver/engine/mcp/supplemental.mjs", noun: "executed", sites: 3, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "driver/outbox-backoff.mjs", noun: "outcome", sites: 5, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "driver/portal-service.mjs", noun: "outcome", sites: 2, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "driver/remedy-accounting.mjs", noun: "executed", sites: 1, atWriteSite: 0, verdict: "out-of-scope" },

package/driver/roster-verdict.mjs

@@ -18,8 +18,8 @@
 //
 //   no configured store
 //       → the bundled roster governs, exactly as it always did — derived by driver/bundled-demos.mjs
-//         from the directory that ships it, never a list written down. On a test box it is CORRECT
-//; anywhere else it means CLEAROTRON_CUSTOMERS_DIR is not reaching the service (#83).
+//         from the directory that ships it, never a list written down. On a test box it is CORRECT;
+//         anywhere else it means CLEAROTRON_CUSTOMERS_DIR is not reaching the service.
 //
 // Pure: no fs, no env, no network. Every input is a parameter so a test can state the whole world.
 

package/driver/search-policy.mjs

@@ -152,7 +152,7 @@ export const COMPONENTS = {
 // so `basis` under-reports and could not carry the distinction even if we wanted it to.)
 //
 // The one mechanical set that stays load-bearing is the FLOORS — a tier-`identical` floor row, live and
-// in an instructed class, gets a full card in EVERY product. That is an obligation (/), not a
+// in an instructed class, gets a full card in EVERY product. That is an obligation, not a
 // priority, and the ladder does not grade it.
 //
 // `graded` means: the stage is told what kind of report it is writing and grades ITS OWN written output.

package/driver/skeptic-record.mjs

@@ -51,7 +51,7 @@ export function escalatedAxes(flagsText, axes) {
   const flags = String(flagsText ?? "");
   if (!flags) return [];
   return axes.filter((a) =>
-    new RegExp(`(^|\\n)\\s*[-*]?\\s*ESCALATE:\\s*${a.replace(/[-]/g, "\\-")}\\b`, "i").test(flags));
+    new RegExp(`(^|\\n)\\s*[-*]?\\s*ESCALATE:\\s*${a.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&")}\\b`, "i").test(flags));
 }
 
 /** Where the call's evidence lives — the driver's own record of what the seat handed it. */

package/driver/stages-knockout.mjs

@@ -418,7 +418,7 @@ export const KO_STAGES = {
       // The depth rule is not stylistic. `# ` opens a SECTION of the delivered report — parseSections
       // splits on /^# /m and batchSummaryOf terminates on it — so a single hash written here ends the
       // client's summary at that line and drops everything after it, silently, on the entry point.
-      `EVERY mark ALSO carries "assessment": the opening read a reader of THIS MARK'S OWN report meets first, before any table. Write it for a client who ordered this one name and nothing else: what the name is, what the landscape around it looks like, what drives the rating, and what a reader should do with that.`,
+      `EVERY mark ALSO carries "assessment": the opening read a reader of THIS MARK'S OWN report meets first, before any table. Write it for a client who ordered this one name and nothing else: what the name is, what the landscape around it looks like, what drives the rating.`,
       `GIVE IT STRUCTURE A READER CAN SCAN — that is what changed. Sub-headers where the content divides, "- " bullets for the load-bearing points, a blank line between blocks. A sub-header is "## " or "### ". NEVER "# ": one hash opens a section of the report itself, and a summary that opens a section ends there and takes the rest of itself off the client's page. A single sub-header over one unbroken block is not structure — the blocks are what make the length readable, and unstructured length is the complaint this replaces.`,
       `KEEP THE LENGTH. It is still the most useful part of a triage and it is still not rationed. What it now has to be is CONSISTENT: this mark's opening read is the scale of a single-mark report's opening read, and the marks of one batch sit within reach of each other. One assessment several times the size of its siblings is out of family. No word count and none is coming — judge it against the other marks in front of you.`,
       `SYNTHESISE THE SOURCES, DO NOT SHELVE THEM SEPARATELY. Where filings were handed to you for this mark, weigh them in the SAME passage as the marketplace and common-law reading — what the screened field shows, what those filings do to that reading, and what the two together mean for the band. A reader must not be handed one block per source and left to reconcile them.`,

package/driver/stages.mjs

@@ -2154,7 +2154,7 @@ export const STAGES = {
     const supplementalLane = !!registerPlan?.contract?.supplemental_lane;
     return lines(
       `First, read and follow exactly: skills/clearance-register/SKILL.md (the shared spine) then skills/clearance-register/unit.md (MODE A — UNIT). Do NOT read digest.md (digest-mode judgment a unit must never run).`,
-      // WHAT THE KEY ALSO CARRIES — COMPOSED, NOT DOCTRINE ( /).
+      // WHAT THE KEY ALSO CARRIES — COMPOSED, NOT DOCTRINE.
       // `unit.md` used to name three tools flat, and on a deployment withholding two of them the seat was
       // told it holds tools its grant does not carry. The composer derives the list from the same table
       // that does the excluding, and returns NULL — not an empty sentence — when the provider cannot be