clearotron 0.2.1 → 0.2.2

package/driver/record-carry.mjs

@@ -103,7 +103,7 @@ export const TRACE_SCOPE = {
   uninstrumented: [
     { path: "common-law", reason: "common-law-grid.json → findings is not joined here; a candidate lost on that path emits NO row and this trace can say nothing about it either way" },
     { path: "case-law", reason: "case-law findings are not traced to a record at all" },
-    { path: "serp/nativeread", reason: "the #372 slices ARE built and write _driver/jx/zh-grid.json; nothing on them reaches this trace because it traces the register path only. Their carry is #402's, on the common-law tracer, because zh-grid.json carries the common-law cells[]+gaps[] shape and not a register band" },
+    { path: "serp/nativeread", reason: "reason: and write _driver/jx/zh-grid.json; nothing on them reaches this trace because it traces the register path only. Their carry is the common-law tracer's, because zh-grid.json carries the common-law cells[]+gaps[] shape and not a register band" },
     { path: "crowd remainder", reason: "count-only slices have no record bodies — enumerated per slice in untraceable_slices[], never per record" },
   ],
 };
@@ -125,7 +125,7 @@ export const TRACE_SCOPE = {
 // the only direction that also hides the 2 unreasoned drops the common-law trace DID find.
 //
 // So the declaration is derived from which sibling tracers actually produced a computable artifact on
-// THIS run, exactly as 's dictated set is read from the paths factory and 's obligations are one
+// THIS run, exactly as the dictated set is read from the paths factory and the obligations are one
 // calculation. A hand-kept list whose staleness is invisible is not a contract; it is a comment.
 //
 // UNCHANGED IN THE CONSERVATIVE DIRECTION: a path only moves to `instrumented` on positive evidence that
@@ -840,7 +840,7 @@ export function silentlyLostFindings({ reconciliation = null, carryRows = null,
  * 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
+ * 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
  * WITH a reason, so they sat outside the sibling's population by design:
@@ -880,12 +880,12 @@ export function statedDivergenceFindings({ reconciliation = null, carryRows = nu
   //
   // 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`:
+  // the very delivery it was written for. Replayed against that delivery:
   //
   //   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
+  // 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
   // were lost sit in the CARRY rows and the reconciliation never mentions them:
   //

package/driver/recording-agreement.mjs

@@ -25,7 +25,7 @@
 //       owns. Measured consequence, not a hypothesis: on 2e203b75 a blind-frame seat obeyed the prose and
 //       hand-wrote a 17182B model with no call capture beside it, on a box whose grant already carried
 //       the tool. The dictation deletes are; this direction is what keeps them deleted.
-//   (c) ORDERED BUT NOT GRANTED.  's seed direction. E12 owns it for skill docs; here it reaches the
+//   (c) ORDERED BUT NOT GRANTED.  That seed direction. E12 owns it for skill docs; here it reaches the
 //       dispatch and the repair ladder too.
 //
 // ── PURE, AND THAT IS WHAT MAKES THE PLANTS CHEAP ────────────────────────────────────────────────────
@@ -182,7 +182,7 @@ export function bareGrant(granted) {
  *   be silent on whichever repair path it did not happen to hold.
  * @param {Array<{surface:string, kind:string, text:string}>} a.union
  * @param {string[]} a.toolUniverse          every tool name that exists anywhere, for direction (c)
- * @param {Array<{stage:string, tool:string}>} [a.backlog]  's named, excused members — ONE list, read
+ * @param {Array<{stage:string, tool:string}>} [a.backlog]  the named, excused members — ONE list, read
  *   from contract-dictation-registry.mjs. A second excuse list here would be authoring number eight, which
  *   is the failure that registry's own header exists to forbid.
  * @param {Set<string>} [a.providerConditionalSurfaces]  surfaces that are provider-conditional BY
@@ -284,7 +284,7 @@ export function agreementFindings({ stage, granted, artifacts, union, toolUniver
   const excused = new Set(backlog.filter((b) => b.stage === stage).map((b) => b.tool));
   for (const tool of [...toolUniverse].sort()) {
     if (held.has(tool)) continue;
-    if (excused.has(tool)) continue;                 // named on 's backlog; the list can only shrink
+    if (excused.has(tool)) continue;                 // named on the backlog; the list can only shrink
     for (const m of union) {
       if (!namesTool(m.text, tool)) continue;
       // ── — A PROVIDER CANNOT SERVE IT, AND THIS ORDER SAYS SO ──────────────────

package/driver/reference-score.mjs

@@ -235,7 +235,7 @@ export function matchesReference(ref, candidate, { sameOwner = false } = {}) {
     return null;
   }
 
-  // 3 — ALIAS. splits this in two, on the same precedent as rules 1 and 4 (, "the scorer calls
+  // 3 — ALIAS. splits this in two, on the same precedent as rules 1 and 4 ("the scorer calls
   // a different owner's longer mark a hit"). This rule was the one cross-owner escape left open.
   //
   // FULL IDENTITY — one name on each side and they are the same name — is NOT a relaxation and stays
@@ -674,7 +674,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 R2 russet-kestrel: `Novartis AG: reference "DELFITY" is withheld, surfaced "DELPHINA"
+  // It fired on a delivered R2 run: `<large filer>: 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
@@ -749,7 +749,7 @@ export function scoreRecall({ reference, findings = [], retrieved = [], scopeCla
  * AND THE DIRECTION IS THE DANGEROUS ONE. A `withheld` that over-counted would be investigated the first
  * round it appeared. This one reads clean.
  *
- * This does NOT compute carry-through — that needs the run's screened set and is 's acceptance 1.
+ * This does NOT compute carry-through — that needs the run's screened set and is the acceptance 1.
  * What it does is stop a bare `0` from reading as "nothing was dropped", by naming on the line how many
  * retrieved marks the number could not have spoken to. The file already refuses a bare `0` for the
  * no-`_driver/` case, in as many words; this is the same refusal for the case that reads clean.
@@ -1638,7 +1638,7 @@ export function ownersMatch(a, b) {
  * derives the same sentence from the delivery-time record instead: slice 1 from its per-lane map
  * (`slices.candidates.lanes[lane]`), slices 2–3 from their own `lane` field. PER LANE, never the
  * run-level join: the SERP grid is zh-only, so `lane ja: executes=candidates+serp-grid` would be a
- * claim about the ja lane that no record supports ('s fix, kept exact here).
+ * claim about the ja lane that no record supports (the fix, kept exact here).
  *
  * THREE ANSWERS, AND THE THIRD IS THE ONE THAT MATTERS:
  *   "candidates+serp-grid"  the named slices ran for this lane
@@ -1710,7 +1710,7 @@ export function readJxLanes(doc) {
       // — DERIVED from fold.slices, with the declaration as a LEGACY fallback only. Two artifact
       // generations reach this line and they are read in this order deliberately:
       //   fold.slices present     → derive. The record of what ran wins, always.
-      //   pre- artifact       → its frozen `lanes.<lane>.executes` string, the only thing that run
+      //   pre-change artifact       → its frozen `lanes.<lane>.executes` string, the only thing that run
       //                             ever recorded (a run minted between  and  carries BOTH, and
       //                             the derived value is the accurate one — hence the order).
       //   neither                 → null ⇒ the scorer prints "(not stated)". Not "none": no statement
@@ -1755,7 +1755,7 @@ export function readJxLanes(doc) {
     why: lanes.length ? null : "_driver/jx-lanes.json is present and declares no lane — the file was written and no jurisdiction lane was built, which is not the same as the file being absent",
     lanes,
     // — the RUN-level statement, three-valued on itself in the same discipline as the rest of this
-    // function: present, or absent with a reason. A pre- artifact and a fold that never ran are both
+    // function: present, or absent with a reason. A pre-change artifact and a fold that never ran are both
     // "the run did not state it", and neither is a pass.
     statement: typeof doc.fold?.executes === "string" ? doc.fold.executes : null,
     slices: doc.fold?.slices ?? null,
@@ -1778,7 +1778,7 @@ export function readJxLanes(doc) {
  *   present, no units    `present:true, units:[]` — its own fact, its own sentence.
  *   present, with units  each unit's own `degraded` / cause / attempts, nothing inferred.
  *
- * `degraded` is TYPEOF-tested, never coerced. A pre- units.json carries the cause STRING in that
+ * `degraded` is TYPEOF-tested, never coerced. A pre-change units.json carries the cause STRING in that
  * field; `Boolean(r.degraded)` would report an old artifact as having stated something it never stated.
  *
  * PURE.

package/driver/refusal-bound.mjs

@@ -2,7 +2,7 @@
 // Copyright 2026 Cordillera Sàrl. Additional terms under section 7 of the AGPL-3.0 apply — see ADDITIONAL-TERMS.md
 // ── ONE REFUSAL BOUND FOR EVERY TRANSPORT THAT LOOPS PER-ITEM OBLIGATIONS ─────────────────────────────
 //
-// 's Part 2. is the incident: one row of a meaning sweep was refused 217 times across three
+// That Part 2. is the incident: one row of a meaning sweep was refused 217 times across three
 // attempts, exhausted the stage's recoveries, and killed a production run that had already ruled 72 of
 // its 73 obligations. Nothing delivered. The cure at that stage was a per-row bound and a park; this
 // module is that cure written once, so the other members of the class do not each grow their own.
@@ -33,7 +33,7 @@
 //                             1,256 rows before this was built: present and distinct in every one.
 
 /**
- * THE BOUND. Thirty, inherited from 's disposition park, where the number was argued from a real
+ * THE BOUND. Thirty, inherited from the disposition park, where the number was argued from a real
  * ledger rather than chosen: twelve is refuted (two rows that were CONVERGING sat at 17), and 30 is still
  * a sevenfold cut from the 217 that killed the run. That argument is about the SHAPE of a live-lock, not
  * about meaning obligations, so it carries to the other members unchanged.
@@ -56,7 +56,7 @@ function* refusals(verdicts) {
 /**
  * How many times each item has been refused so far. PURE — the park's own evidence.
  *
- * COUNTED PER ITEM ACROSS CALLS, which is the unit 's banner records an earlier investigation dying
+ * COUNTED PER ITEM ACROSS CALLS, which is the unit the banner records an earlier investigation dying
  * on when it joined per-item-final-state instead. A row refused on eight calls and ruled on the ninth
  * counts eight; a row refused eight times in ONE call also counts eight, because eight refusals is eight
  * refusals however they were batched.

package/driver/register-availability.mjs

@@ -17,7 +17,7 @@
 // The first cut narrowed the contract's covered list to the configured members and handed that
 // downstream. It is wrong twice over:
 //
-//   · 's admission gate reads `offices.covered` to decide which territories a client may ORDER.
+//   · the admission gate reads `offices.covered` to decide which territories a client may ORDER.
 //     Narrowing it to EU would refuse a US-only matter AT THE DOOR, on a provider that covers the US.
 // is the report of that shape of refusal and its acceptance is that a US-only scenario is
 //     admitted rather than vetoed. A door that refuses is not a disclosure.
@@ -130,7 +130,7 @@ export function unavailableByOffice(unavailable) {
  * against the full declared coverage and hand them straight to the provider adapter. On a composite
  * that is a fan-out to EVERY member, so the unconfigured one is asked, refuses, and the composite
  * correctly declines to return a partial sum — killing a lane whose other half works perfectly. That
- * is 's observed refusal, and 's acceptance ("free-tier starts and ships a disclosed US
+ * is the observed refusal, and the acceptance ("free-tier starts and ships a disclosed US
  * deferral") was never met on these two lanes.
  *
  * @param regions      what resolveRegions produced, against the FULL coverage. `[]` is meaningful.

package/driver/register-count.mjs

@@ -533,7 +533,7 @@ export function countLine(entry) {
   //
   // On the rendered line rather than only in `scope.deferredJurisdictions`, which has been written by
   // both Depth 2 lanes since they were built and which `git grep` finds no reader for. A field nobody
-  // sees is not a disclosure — that is 's defect exactly, where `deferred_coverage` rode the plan
+  // sees is not a disclosure — that is the defect exactly, where `deferred_coverage` rode the plan
   // and the run shipped an EU-only clean with no row saying the US register was never searched.
   const deferred = entry.deferredScope ?? [];
   const oneDeferred = deferred.length === 1;

package/driver/register-grant-vocabulary.mjs

@@ -7,7 +7,7 @@
 // `unit.md` is provider-INDEPENDENT doctrine, and it named three provider-DEPENDENT tools flat:
 // "Your register key also carries register_record_fetch, register_image_fetch and register_batch_screen."
 // On a signa deployment two thirds of that sentence is false and the seat is told it holds tools its
-// grant does not carry; the same shape is 's subject across six
+// grant does not carry; the same shape is the subject across six
 // providers. A dispatch that asserts a capability the active provider lacks is the defect, whatever the
 // seat then does with it.
 //
@@ -39,7 +39,7 @@ export const HELD_BUT_NOT_CALLED = Object.freeze([
  * ✕ NULL IS NOT AN EMPTY SENTENCE, and the difference is the defect this exists to fix. Ask
  * `providerUnavailableRegisterTools` on an unresolved provider and it answers with an empty withheld
  * set — deliberately, as a reporting helper that must never throw. Composed into this sentence, an empty
- * withheld set reads as "your grant carries all of them": 's defect, restored
+ * withheld set reads as "your grant carries all of them": the defect, restored
  * silently, on exactly the `--experiment` single-stage path a diagnosis reaches for. So resolution is
  * asked for HERE, and an unresolved provider omits the sentence rather than composing a false one.
  */

package/driver/register-plan.mjs

@@ -74,7 +74,7 @@ export const PLAN_PREDICATES = ["exact", "default", "wildcard", "phonetic", "own
 // ratified mark or its dominant element, i.e. run input. Until now the only marking was a `+form` suffix
 // inside a qid string, and the wildcard fringe carried none at all — so nothing downstream could tell a
 // generated term from an imagined one without re-deriving the band. OPTIONAL on the entry: a frozen
-// pre- plan carries none and resumes byte-identical, and replay verdicts over archived runs never flip.
+// pre-change plan carries none and resumes byte-identical, and replay verdicts over archived runs never flip.
 /**
  * THE ROMANISATION THE PLAN ALREADY HOLDS FOR A TERM — (cause 2).
  *
@@ -470,7 +470,7 @@ const slug = (s) => latinFold(s) || "q";
 // So a non-Latin term's identity carried nothing about WHICH TERM IT IS. It was its position in the
 // compile order — and the counter is per-plan, not per-script, so adding a Devanagari term renumbers
 // the Cyrillic ones. Fourth site of a Latin normaliser standing where an identity should be, after
-// 's fold key, 's script-exact arm and 's term-substance check.
+// That fold key, the script-exact arm and the term-substance check.
 //
 // ── WHAT IT COSTS, MEASURED ON THE SHIPPED extendRegisterPlan RATHER THAN REASONED ────────────
 //
@@ -1277,7 +1277,7 @@ export function entryQuestionKey(entry, plan) {
  * straight out of model-authored common-law markdown, and it is where R2b's two heading
  * rows entered a plan that had already been declared clean.
  *
- * — AND IT SCREENS FOR THE QUESTION, not just the qid. Same argument as 's term screen and
+ * — AND IT SCREENS FOR THE QUESTION, not just the qid. Same argument as the term screen and
  * the same funnel: an entry whose resolved question is already in the plan is refused here, because
  * this is the one place that holds both the plan and the incoming row. See entryQuestionKey above
  * for what "the same question" means and why `regions` is the field that hides it.
@@ -1498,7 +1498,7 @@ export function parseRegisterPlan(raw) {
     // owner is a defect, never a silent no-op filter.
     if (e.owner != null && (typeof e.owner !== "string" || !e.owner.trim()))
       throw new Error(`register_plan_owner_invalid:${short(e.qid)} (owner must be a non-empty string when present)`);
-    //: optional (a frozen pre- plan has none), closed when present — an off-enum value would
+    //: optional (a frozen pre-change plan has none), closed when present — an off-enum value would
     // make the floor/model marking unreadable exactly where it is load-bearing.
     //: optional (a frozen pre-2050 plan has none), and closed to the single value `true` when
     // present — a falsy or string-shaped stamp would make the depth fold's designation unreadable
@@ -1532,7 +1532,7 @@ export function parseRegisterPlan(raw) {
  *   { executed: [{qid, state, records, total_hits}], missing: [qid], skipped: [{qid, guard}],
  *     unplanned: [{qid|query}] }
  * `records` and `total_hits` are each a number or null, and BOTH KEYS ARE ALWAYS WRITTEN.
- * That is load-bearing, not tidiness: `planJoinFrom` tells a pre- receipt from a count the
+ * That is load-bearing, not tidiness: `planJoinFrom` tells a pre-change receipt from a count the
  * provider could not take by whether the keys are PRESENT, because `null` and absent are the same
  * value once read. Omit a key here and every new receipt silently reads as legacy — the arm named
  * "the discriminator's PREMISE" fails if this stops holding.
@@ -1628,7 +1628,7 @@ export function joinPlanToBands(plan, bandBlocksByAxis) {
 //
 //   1. THE PROVIDER MUST HAVE ANSWERED. Deferral is earned by a band block stamped `error:true` with the
 //      provider's own reason on it. A qid with NO block ran nothing and recorded nothing — an absence,
-//      not a finding — and still throws. That is 's condition, untouched: a genuinely-unrun,
+//      not a finding — and still throws. That is the condition, untouched: a genuinely-unrun,
 //      undisclosed slice fails the run.
 //   2. THE LADDER MUST BE SPENT, WHERE THE LADDER CAN DO ANYTHING. Only a qid the run has ALREADY
 //      recorded as missing (or already deferred this way) converts. On its first fan-in a hard-errored
@@ -1847,7 +1847,7 @@ export function deriveCoverageSkeleton(plan, join) {
  * predicate, no clean-claim precondition — had already fired and returned first. Main's own doc block
  * called that pair a deliberate superset/subset. So the fold removes a token the validator could not
  * reach, not a check. THE FOLD IS PROVED BY THE REPLAY CORPUS, not by that argument: the corpus flips
- * only where the SUPERSET stops firing, and it comes back to 's 9 with the superset alone restored.
+ * only where the SUPERSET stops firing, and it comes back to the 9 with the superset alone restored.
  * (The argument alone has a hole — this function keys its skeleton map on raw `s.axis` and the superset
  * trims, so an untrimmed skeleton axis would separate them. Degenerate, and no preserved run carries it.)
  *
@@ -2066,7 +2066,7 @@ function undisclosedDeferredQids(skeletonAxis, text) {
  * WHY THIS AND NOT A LOUDER HINT. The doctrine already reached the stage as advice on the first dispatch
  * (deferredSlicesRequiredRows, formerly the A8 "hint") and the stage claimed clean anyway, then complied
  * the moment the identical fact came back as a validator failure — R1 681s→202s, R2 515s→77s, every
- * prelim run that reaches the digest. A fact that is obeyed as a failure and ignored as an input is not
+ * clearotron run that reaches the digest. A fact that is obeyed as a failure and ignored as an input is not
  * being said too quietly; it is being offered rather than required. So it is required here.
  *
  * DELIBERATELY A SUPERSET of the deferred branch below, and the older gate is kept rather than folded

package/driver/register-records.mjs

@@ -330,7 +330,7 @@ export function recordsForMark(doc, name) {
  * WHAT REPLACES A FOREIGN URL, and why it is not an origin swap: `null`, so the surfaces fall through to
  * `recordId` — the `/mark/<cc>/<number>` path that IS the canonical record identity this system stores.
  * The reader gets the record number in plain text beside the office label, which is word for word the
- * remedy 's refusal message prescribes. Composing the run provider's origin onto the path instead
+ * remedy the refusal message prescribes. Composing the run provider's origin onto the path instead
  * would invent a URL nobody fetched, and on `free-tier` there are two offices and no single origin to
  * swap to.
  *
@@ -394,7 +394,7 @@ export function recordsLine(entry) {
       + `appears here.`
     : "";
   // — the ordered territories this register never covered. Appended to whichever sentence comes
-  // back, and needed most in the EMPTY-LIST branch below for the same reason 's note is: "the
+  // back, and needed most in the EMPTY-LIST branch below for the same reason the note is: "the
   // register returned none under the name or any close variation of it" is a clean negative, and over a
   // matter that ordered Japan on a register with no Japanese coverage it is a false one.
   const outside = entry.deferredScope ?? [];

package/driver/registry-fidelity.mjs

@@ -328,7 +328,7 @@ export function assembleRunRecords(runDir, runPrefix,
       writeFileSync(driverDir(runDir, "receipts.json"), JSON.stringify({ schema_version: 1, receipts: rows }, null, 2) + "\n");
     }
   } catch { /* best-effort — the records map above remains the gate substrate */ }
-  // 's legacy-name notice is REPLACED, not deleted. That one told an operator which of four
+  // That legacy-name notice is REPLACED, not deleted. That one told an operator which of four
   // global candidates was being read; nothing reads any of them for a new run any more, so the sentence
   // had become false. What an operator still needs is the fact underneath it: a box upgraded across this
   // change is carrying a large global record log that is now written by nothing and read by nothing —
@@ -338,7 +338,7 @@ export function assembleRunRecords(runDir, runPrefix,
   //
   // AND THE CALL LEDGER'S OWN NOTICE MOVES HERE RATHER THAN DYING WITH IT. `ledgerDeprecationNotice` had
   // exactly one product caller — the record line above — so deleting that line would have left NOTHING
-  // announcing the ledger that is still global, still live and still on production's pre- filename.
+  // announcing the ledger that is still global, still live and still on production's pre-change filename.
   // Gated on the path ACTUALLY WALKED: the notice re-resolves from the environment, so on a call that
   // passed an explicit `callLogPath` it would describe a file this assembly never opened, and a
   // diagnostic that names something other than what happened is worse than no diagnostic.
@@ -951,7 +951,7 @@ const recClasses = (rec) => {
  * WHICH owner name a delivery artifact SHOWS. ONE definition, deliberately, because the renderer
  * and bindFindingsToRecords each resolve the owner independently — publish/render.mjs does its own
  * record lookup and preferred the record outright, so binding the finding alone changed no heading and
- * no lint surface. A second copy of the same decision is how 's provider default survived two fixes.
+ * no lint surface. A second copy of the same decision is how the provider default survived two fixes.
  *
  * The record decides, not a guess about what "looks romanised": a record carrying BOTH a Latin name and
  * a native-script one is itself saying the Latin field is a transliteration, and only then does a

package/driver/remedy-accounting.mjs

@@ -227,7 +227,7 @@ export function accountRemedyTerms({ terms = [], blocksByQid = new Map(), execut
 }
 
 /**
- * THE CLOSURE READ ('s second criterion). `domClosed` may be true only over the ACCOUNTED set: a
+ * THE CLOSURE READ (the second criterion). `domClosed` may be true only over the ACCOUNTED set: a
  * dominant-element directive must be verified-closed AND every remedy term that directive restated must
  * be `found` or `searched-empty`. One unaccounted term and the dominant-element gap is not closed —
  * because it demonstrably is not: something the remedy named either never ran or ran into a shape the

package/driver/repair-composers.mjs

@@ -199,7 +199,7 @@ export const REPAIR_COMPOSERS = [
         // before/after run-pairs read identically, because a clearance narrative's job IS to state what
         // was searched and what came back — the legitimate sentence and the defective one have the same
         // shape and differ only in truth. The typed half of this class IS enforced structurally, on the
-        // corrective pair, by `evidenceClaimViolations` (, pipeline.mjs ~10973) — but it reads
+        // corrective pair, by `evidenceClaimViolations` (pipeline.mjs ~10973) — but it reads
         // `findings.json` meters, and a narrative sentence with no findings-side counterpart is invisible
         // to it. That prose gap is conversion-era work, not an instruction. This is the instruction.
         `A REPAIR MAY NARROW A CLAIM AND MAY NEVER BROADEN ONE. If a flagged statement is wrong because it claims too much, the correction states LESS: strike the claim, or replace it with the smaller claim the evidence actually carries. Never restate the same claim in different words, and never replace a specific sentence with a general one. NARROWING IS NOT HEDGING and the rule above still holds — claiming less is a correction; keeping the claim and wrapping it in "may", "appears to" or "broadly" is the hedge that is forbidden.`,
@@ -233,7 +233,7 @@ export const REPAIR_COMPOSERS = [
         review,
       );
     },
-    // TWO SAMPLES BECAUSE THE COMPOSER HAS TWO SHAPES, and 's saving is the whole point of the
+    // TWO SAMPLES BECAUSE THE COMPOSER HAS TWO SHAPES, and the saving is the whole point of the
     // second: a declared scope narrows the pass, an undeclared one leaves it byte-identical to what it
     // was before that existed. A guard walking only one of them walks half the surface.
     samples: [

package/driver/repair-digest.mjs

@@ -139,7 +139,7 @@ export function aggregateFailureRecurrence({ enumerate = enumerateRuns, now = Da
   // different orders), so it never enters bySig — but a count that nobody prints is a diagnostic
   // computed and dropped, which is the class this issue belongs to.
   const refusals = { count: 0, runIds: [], stages: [] };
-  // — counted and NAMED, never dropped: 's shape immediately above, for the same reason. A park
+  // — counted and NAMED, never dropped: the shape immediately above, for the same reason. A park
   // whose class was "unknown" over a reason a validator had already structured is a gap in the
   // classifier, not an unknowable failure, and the digest is where an operator would ever see it. It is
   // reported BESIDE the groups rather than inside them: it is a fact about how a failure was classified,
@@ -219,7 +219,7 @@ export function renderFailureRecurrence(agg) {
     ].filter(Boolean).join("\n")
     : null;
   if (!agg.groups.length) {
-    return `No prelim failures or auto-recovery parks in the last ${agg.days} days.${refusalLine ? `\n${refusalLine}` : ""}${gapLine ? `\n${gapLine}` : ""}`;
+    return `No clearotron failures or auto-recovery parks in the last ${agg.days} days.${refusalLine ? `\n${refusalLine}` : ""}${gapLine ? `\n${gapLine}` : ""}`;
   }
   const head = (g) =>
     `${n(g.runIds.length, "run")}  ${g.sig}  [${g.failClass ?? "?"}]  ` +
@@ -247,7 +247,7 @@ export function renderFailureRecurrence(agg) {
 }
 
 // CLI: `node repair-digest.mjs [--days N]` — the ops-digest generator (scripts/ops-digest-daily.sh)
-// invokes this and pastes the output into its "Prelim Failure Recurrence" section.
+// invokes this and pastes the output into its "Clearotron Failure Recurrence" section.
 if (isEntrypoint(import.meta.url)) {
   const ix = process.argv.indexOf("--days");
   const days = ix >= 0 ? Math.max(1, Number(process.argv[ix + 1]) || 7) : 7;

package/driver/repairs.mjs

@@ -59,7 +59,7 @@ export const REFUSAL_TERMINAL_KIND = "designed-refusal";
 // rejection carried one, and the errno tokens below matched it; but undici reports a codeless fault as
 // a bare `TypeError: fetch failed` (no cause.code), and that line — transport noise by construction —
 // carried no token either regex knew, so it classified DETERMINISTIC at fan-in: loud-terminal, but it
-// defeated 's weather lane for exactly the unreachable-provider case the lane exists for.
+// defeated the weather lane for exactly the unreachable-provider case the lane exists for.
 export const TRANSIENT_RE = /\btimeout\b|\blane_wedge\b|\bembedded_fallback\b|\bnonzero_exit|\bunparseable_json\b|\bstatus_(timeout|overloaded|error|aborted|rate_limited)\b|\brate_limited\b|\boverloaded\b|\beconnreset\b|\betimedout\b|\benotfound\b|\beai_again\b|socket hang\s?up|\bhttp\s?5\d\d\b|\btransport failure\b/i;
 
 // STRUCTURAL REFUSAL: the provider ANSWERED, and its answer is a verdict on the REQUEST. The remedy is
@@ -140,7 +140,7 @@ export const DETERMINISTIC_RE = /\bhttp\s?4(0[0349]|1[04])\b|uri too long|own no
 //
 // The axis outcome survives as evidence in exactly one case: THE AXIS LANDED NOTHING. Zero qid-stamped
 // blocks means the executor never wrote, so its transport failure really is this slice's story and
-// 's weather lane keeps working for the dead-provider case it exists for. Once the axis HAS landed
+// That weather lane keeps working for the dead-provider case it exists for. Once the axis HAS landed
 // qid-stamped blocks the executor demonstrably ran and wrote, and this qid's absence is an identity or
 // coverage hole that no repair outcome from its axis speaks to.
 //
@@ -309,7 +309,7 @@ const overflowOf = (tail) => { const m = OVERFLOW_RE.exec(tail.trim()); return m
 // The leading CAUSE CENSUS is the exact count stamped at the throw site, so the total is the sum of its
 // numbers — no comma-splitting, and therefore immune to the over-count a query containing a comma used to
 // cause. LEGACY SHAPES still parse and must: this text path exists for the run-level catch, which sees
-// prose only, and a resumed or archived run can still carry a pre- token
+// prose only, and a resumed or archived run can still carry a pre-change token
 // (`connotation_undisposed:<census>;…`, `<q1,q2,…>[ (+N more)]`). A stale token that stopped counting
 // would read as a MISSING quantity, which is what a converged run looks like.
 // The validator's exact count still rides as `quantity` at the throw site and always wins.
@@ -329,7 +329,7 @@ function undisposedCount(tail) {
   // was cut short of its payload — ABSENT, not converged.
   return named ? named + overflow : null;
 }
-// A pre- archived token: `connotation_recurrent_uncited:<one result, ≤80 chars>[ (+N more)]` — ONE
+// A pre-change archived token: `connotation_recurrent_uncited:<one result, ≤80 chars>[ (+N more)]` — ONE
 // named result plus the overflow. Never split on commas: that payload is a copied result title, not a
 // joined list. Nothing emits this shape any more; it is kept so a resumed run's own history still counts.
 function recurrentCount(tail) {
@@ -621,7 +621,7 @@ export function capParkSchedule({ resetsAt = null, attempts = 0, now = Date.now(
 /**
  * capWaitFrom — what a run actually spent WAITING on a provider's cap, read off the park history.
  *
- * tracker issue 103's fourth ask: a run that still dies on a cap has to SAY it was a cap, and say how
+ * The ask: a run that still dies on a cap has to SAY it was a cap, and say how
  * long it held out. The park history is the only record that survives a park/resume cycle, so it is the
  * only place that answer can come from at the terminal.
  *
@@ -695,7 +695,7 @@ export function humanWait(min) {
 // failure's `quantity` and the last recorded quantity for the SAME signature in the park history. It
 // changes no branch below and no caller reads it as an input: the point of the issue is that the
 // comparison can SEE 25 → 9 → 9 as different from 29 → 11 → 0, where today both hash identically.
-// What the machinery DOES with that difference is 's decision, not this function's.
+// What the machinery DOES with that difference is the decision, not this function's.
 export function decideRecovery({ failClass, sig, reason = "", history = [], priorAttempts = 0, recoveryMax = 3, nonRecoverable = false, hasRunDir = true, runCeiling = null, weatherAttempts = 0, defectAttempts = null, weatherCeiling = null, quantity = null }) {
   const hist = Array.isArray(history) ? history : [];
   const sigAttempts = hist.filter((h) => h?.sig === sig).length;

package/driver/replay-archive.mjs

@@ -217,6 +217,8 @@ export function diffSnapshots(prev, curr) {
 
 function main() {
   const args = new Set(process.argv.slice(2));
+  // ON-DISK NAME, NOT A PRODUCT NAME: an install that never set the variable already has this file, so
+  // renaming the default points the reader at one that does not exist. Owner ruling, tracker issue 308.
   const snapshotPath = process.env.CLEAROTRON_REPLAY_SNAPSHOT || join(homedir(), ".prelim-replay-snapshot.json");
   const roots = process.env.CLEAROTRON_REPLAY_ROOTS
     ? process.env.CLEAROTRON_REPLAY_ROOTS.split(":").filter(Boolean)

package/driver/report-card-record.mjs

@@ -64,7 +64,7 @@ const BODY_FLOOR_CHARS = 60;
  * READ FROM THE RUN, not from the payload. The card's `- Source:` bullet is declared
  * `mechanical:code-rendered` and the record already carries `source.resolved_link`, so the seat is not
  * asked for a URL it would have to compose from a host table it is not even given — the transcription
- * class in its purest form, and 's link-to-nowhere in a document a client reads.
+ * class in its purest form, and the link-to-nowhere in a document a client reads.
  */
 export function findingForOrdinal(runDir, ordinal) {
   return findingsDocFor(runDir, ordinal).finding;
@@ -187,7 +187,7 @@ export function renderReportCard(model, finding, { registerLabel = "" } = {}) {
 // ── THE RISK READ IS A STRUCTURE, NOT A DICTATED HABIT ( D3) ─────────────────────────────────
 //
 // render.mjs suppresses the typed `legal_position` / `practical_position` pair on any card whose prose
-// already carries a "Risk assessment"-led bullet (, ONE ACCOUNT PER FACT). That gate reads a lead
+// already carries a "Risk assessment"-led bullet (ONE ACCOUNT PER FACT). That gate reads a lead
 // this stage's dispatch calls OPTIONAL and this acceptance never checked — the card contract's §L
 // requirement was a HABIT, in exactly the sense the card index was one before the driver bound it.
 //

package/driver/result-noun-fields.mjs

@@ -12,7 +12,7 @@
 // property of the WRITING SITE, not of the name — a field called `outcome` carrying an outcome is fine,
 // and a field called `settled` carrying a dispatch return is the defect. Only reading the writer tells
 // them apart, so the population is SPLIT and classified rather than filtered down to the offenders.
-// Both halves are kept, for 's reason: a filtered population produces no number, and nobody can see
+// Both halves are kept, for the reason: a filtered population produces no number, and nobody can see
 // what was hidden.
 //
 // ── THE TWO HALVES ──────────────────────────────────────────────────────────────────────────────────
@@ -48,7 +48,7 @@
 //                   `outcome` for existing readers beside `dispatch` and `verdict`).
 //   "out-of-scope" — never reaches `_driver/*.json` or `run.jsonl`; `atWriteSite` is 0.
 
-/** The result nouns this sweep is about — 's list, verbatim. */
+/** The result nouns this sweep is about — the list, verbatim. */
 export const RESULT_NOUNS = Object.freeze(["outcome", "executed", "permanent", "settled", "closed", "recovered", "verified"]);
 
 export const RESULT_NOUN_FIELDS = Object.freeze([
@@ -66,7 +66,7 @@ export const RESULT_NOUN_FIELDS = Object.freeze([
   { file: "driver/pipeline.mjs", noun: "executed", sites: 4, atWriteSite: 3, verdict: "result",
     why: "lengths of the executed set as the join computed it" },
   { file: "driver/pipeline.mjs", noun: "outcome", sites: 11, atWriteSite: 6, verdict: "result",
-    why: "the one member that reported an invocation — taint-rerun's `r.ok ? \"ok\" : …`, which travels on a StageFailure packet — now carries a `cleared` sibling read from the taint, #1529's remedy 10/5 -> 11/6 at tracker issue 1886: the profile-store receipt's `outcome: pr.outcome`. Classified by READING ITS WRITING SITE, which is profiles.mjs and not this file: the value is one of three literals chosen by a situation the resolver decided (`overlay` and `bundled-fallback` are `pass`, `env-arrived-late` is `blocked`), never a call's return read as a verdict. `bundled-fallback` being `pass` is the point of the whole receipt — a legitimate install that nobody was told about is what this row says out loud." },
+    why: "the one member that reported an invocation — taint-rerun's `r.ok ? \"ok\" : …`, which travels on a StageFailure packet — now carries a `cleared` sibling read from the taint, the remedy 10/5 -> 11/6 at the profile-store receipt's `outcome: pr.outcome`. Classified by READING ITS WRITING SITE, which is profiles.mjs and not this file: the value is one of three literals chosen by a situation the resolver decided (`overlay` and `bundled-fallback` are `pass`, `env-arrived-late` is `blocked`), never a call's return read as a verdict. `bundled-fallback` being `pass` is the point of the whole receipt — a legitimate install that nobody was told about is what this row says out loud." },
   { file: "driver/pipeline.mjs", noun: "permanent", sites: 1, atWriteSite: 1, verdict: "result",
     why: "`permanent.length` — a count of the classified set" },
   { file: "driver/pipeline.mjs", noun: "recovered", sites: 3, atWriteSite: 3, verdict: "result",
@@ -95,6 +95,13 @@ export const RESULT_NOUN_FIELDS = Object.freeze([
   { file: "driver/skills-store-provenance.mjs", noun: "outcome", sites: 6, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "driver/status-snapshot.mjs", noun: "outcome", sites: 1, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "mcp-server/lib/events.mjs", noun: "recovered", sites: 1, atWriteSite: 0, verdict: "out-of-scope" },
+  // Read at the writing site, as this table requires. All three sites are in `knockoutSearches`, a
+  // READ-ONLY projection that composes the rows `list_searches` answers with: it opens no artifact and
+  // writes nothing, so nothing here can reach `_driver/*.json` or `run.jsonl`. Each value is a literal
+  // chosen from the run's own stored record — "found" or "no-hit" from whether the mark has findings,
+  // and "recorded" for a register term whose stored row says it did NOT answer. None is a call's return
+  // read back as a verdict, which is the defect this table exists to find.
+  { file: "mcp-server/lib/knockout.mjs", noun: "outcome", sites: 3, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "mcp-server/lib/ops.mjs", noun: "settled", sites: 1, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "mcp-server/server.mjs", noun: "outcome", sites: 1, atWriteSite: 0, verdict: "out-of-scope" },
   { file: "scripts/backfill-started-at.mjs", noun: "outcome", sites: 5, atWriteSite: 0, verdict: "out-of-scope" },

package/driver/run-economics.mjs

@@ -87,7 +87,7 @@
 // `modelUsed`. So the rows can now answer "what ran", per record, wherever the wire reported.
 //
 // What has NOT changed is this module: `byBilling` / `byStage` / `dispatches` still key on `modelUsed`,
-// i.e. on what was asked for. Switching them to prefer `modelActual` is 's call, not a side effect
+// i.e. on what was asked for. Switching them to prefer `modelActual` is the call, not a side effect
 //, and it cannot be a blanket flip — codex reports no model, and a killed turn may have none,
 // so a per-record basis is the only honest shape. `tokens.mjs` keys its rollup on the requested alias
 // for the same reason and is likewise untouched.
@@ -241,7 +241,7 @@ export const vendorOf = (engine) => ENGINE_VENDORS[String(engine ?? "")] ?? null
 //
 // CODE-SIDE IS NOT A VENDOR. `code:execute-plan` rides nearly every run (the driver executes the frozen
 // plan itself), stamps `authMode: "not-provider-billed"`, and costs no provider tokens. Counting it would
-// make every run in the product read as multi-vendor — the same defect as 's `web` channel, where a
+// make every run in the product read as multi-vendor — the same defect as the `web` channel, where a
 // member the driver always adds made every run look unplanned. Provider-billed rows only, and the count
 // of what was set aside is reported so the exclusion is visible rather than assumed.
 //

package/driver/run-integrity.mjs

@@ -42,7 +42,7 @@ import { DISPATCH_SUFFIX } from "./dispatch-record.mjs";        // — the dispa
  *
  * ONE PREDICATE, so the snapshot and any future arming decision cannot disagree about the set. Named
  * files are the driver-derived joins and receipts judgment reads; the dispatch records are what was
- * actually asked, including 's `.prev-<sha>` supersede chain.
+ * actually asked, including the `.prev-<sha>` supersede chain.
  *
  * ──: EVERY `.jsonl` IS OUT, BY PATTERN, AND A NEW SINK IS OUT THE MOMENT IT IS CREATED ────────
  *