clearotron 0.2.2 → 0.2.4

package/driver/skills/prelim-variants/SKILL.md

@@ -125,8 +125,8 @@ LUMENGARDE is the distinctive anchor — risk concentrates on coined-word axes a
 
 **A variant VALUE is a mark term, never a note about one.** A parenthetical, sentence punctuation
 (`—`, `;`) or a space-flanked slash makes it a label, and a label dispatched verbatim returns a
-confident zero over marks that exist — a nil search that reads as a clean. Write `ZEPHYR`, not
-`ZEPHYR (root)`; the rationale column is where the note belongs. The compiler refuses annotated values
+confident zero over marks that exist — a nil search that reads as a clean. Write `COASTLINE`, not
+`COASTLINE (root)`; the rationale column is where the note belongs. The compiler refuses annotated values
 whatever their length, so a two-word one is caught the same way a long one is.
 
 **If a value genuinely IS a mark carrying that punctuation** — a device mark recorded with its Vienna
@@ -178,7 +178,7 @@ silently narrows what was searched, and the deferred row is the honest outcome.
 
 ### Watchlists
 
-- **Aggressive enforcers:** Nordwave, Aurora Interactive
+- **Aggressive enforcers:** Nordwave, Foxglade Interactive
 - **Major brand owners:** Sony, Aureon, Nintendo, HP, Activision, Take-Two, EA
 - **Competitors:** Epic Games, Valve, Unity, Riot Games
 

package/driver/stage-context.mjs

@@ -369,6 +369,19 @@ export const DISPATCH_EXTRAS = [
       { path: join(P.runDir, "_records"), dir: true, why: "assembleRunRecords — the fetched official records each claimed field is checked against; without them the check finds zero mismatches and the block silently vanishes" },
     ],
   },
+  {
+    // Rule 1 of the two-register rule, measured over the record's default-visible lines and handed to
+    // the pass that already rewrites. Advisory by construction: it reaches the writer, never the reader.
+    //
+    // It reads the RECORD rather than the narrative, and that is the point — the lines a client meets
+    // first are typed fields (each conflict's one sentence, the coverage notes, the actions, the mark
+    // assessment's two reads), not prose to be re-parsed out of a document. A sandbox without this file
+    // composes no block, which is correct and visible: the composer stamps what it built.
+    id: "refute-plain-register", stage: "narrative-refutation",
+    reads: (P) => [
+      { path: P.findings, why: "plainRegisterExtra reads the typed default-visible fields — net, coverage notes, actions, mark assessment — and the owners it must blank before reading" },
+    ],
+  },
   // ── — synthesis's two, and the asymmetry they close ─────────────────────────────────────────
   //
   // The reviewer received the plan-execution receipt as a code-derived table; the stage it reviews

package/driver/stages.mjs

@@ -66,9 +66,9 @@ export { REGISTER_AXES, decideAxes };
 //
 // (stages.mjs cannot import pipeline.mjs — pipeline imports stages — and stage-context.mjs, where the
 // extras are declared, imports stages.mjs too. stages.mjs is the one home both sides can reach.)
-export function stampDispatchBlocks(ctx, stage, { built = [], failed = [] } = {}) {
+export function stampDispatchBlocks(ctx, stage, { built = [], failed = [], empty = [] } = {}) {
   if (!ctx || typeof ctx !== "object") return;
-  ctx.dispatchBlocks = { ...(ctx.dispatchBlocks ?? {}), [stage]: { built: [...built], failed: [...failed] } };
+  ctx.dispatchBlocks = { ...(ctx.dispatchBlocks ?? {}), [stage]: { built: [...built], failed: [...failed], empty: empty.map((e) => ({ ...e })) } };
 }
 
 // Three states, and the third is the point: ABSENT IS NOT CORRUPT. A run with no register plan is a
@@ -85,7 +85,7 @@ export function dispatchBlockState(ctx, stage, id) {
   if (!rec) return "absent";
   if (rec.built?.includes(id)) return "present";
   if (rec.failed?.some((f) => f.id === id)) return "failed";
-  return "absent";
+  return rec.empty?.find((x) => x.id === id)?.kind ?? "absent";   // ran and produced no text; WHICH nothing is the builder's own word — see `nothingFound` at the foot of this file
 }
 
 // ── The two synthesis lines that make a claim about the blocks, branched in ONE place ──────────────
@@ -1301,7 +1301,7 @@ export const STAGES = {
       job.jurisdictions ? `Instructed territories (AUTHORITATIVE scope — do NOT widen to "major markets"): ${Array.isArray(job.jurisdictions) ? job.jurisdictions.join(", ") : job.jurisdictions}` : "",
       job.customer ? `Customer/applicant (from the intake brief — drives the self-exclusion set): ${job.customer}` : "",
       // WS-B profile defaults — falsy-omitted, so an empty profile renders this message byte-identical
-      // to the pre-profile shape (the aurora/generic regression anchor).
+      // to the pre-profile shape (the regression anchor).
       // Industry is CONTEXT not a rule (Design Law #1): it sharpens which sectors/adjacencies matter for
       // the vertical (e.g. food/ingestible adjacency for a beverage brand), it never dictates a conclusion.
       profile?.industry ? `Customer industry (context for sector framing — let it sharpen the relevant sectors and adjacencies for this vertical; it is context, never a rule that decides a finding): ${profile.industry}.` : "",
@@ -1813,7 +1813,7 @@ export const STAGES = {
       // DETERMINISTIC GRID (robust fix, 2026-06-14): when the driver wrote a grid-spec, the model is OUT
       // of the grid data path entirely — it passes grid_spec_path, the plugin runs the dictated cells and
       // WRITES common-law-grid.json from the API response (no truncation, no dropped/mis-keyed cells), and
-      // the model only judges the returned candidates. This is the structural cure for both the Zephyr
+      // the model only judges the returned candidates. This is the structural cure for both the dense-marketplace
       // truncation and the NOVA PULSE dropped-cell failures (no tier bump would fix the output ceiling).
       if (gridSpecPath) {
         return lines(
@@ -2353,7 +2353,7 @@ export const STAGES = {
       },
       "placements.json — the structured mirror, keys EXACTLY {mark, owner, jurisdiction, records, tier, reason} + optional borderline": {
         class: "mechanical:code-rendered", tokens: ["placementmodel_missing", "placements_unparseable", "placements_key_unknown", "placement_invalid", "placement_key_unknown"],
-        why: "The driver renders it: renderPlacementsJson() in placement-form.mjs over the union, landed by gateway.mjs:706 (the #562 union-then-render block; re-verified 2026-08-29 — the old :507 predated this branch and pointed at the engine-resolution doc comment). The skill file was not updated with #562, so the stage's two sources contradict each other — the contract that escapes if E1 is authored against stages.mjs alone. [citation unverified]",
+        why: "The driver renders it: renderPlacementsJson() in placement-form.mjs over the union, landed by `syncPlacementForm` in gateway.mjs (the union-then-render block). Cited by SYMBOL because the number has now moved twice: an earlier :507 pointed at an engine-resolution comment, and :706 went blank when an unrelated block was inserted above it. The skill file was not updated with #562, so the stage's two sources contradict each other — the contract that escapes if E1 is authored against stages.mjs alone.",
       },
       "mark / owner / records / territories / classes on a SELECTED row": {
         class: "mechanical:code-extracted", tokens: [],
@@ -3222,7 +3222,7 @@ export const STAGES = {
       // lane's own prose contract. Two of the four longest sentences in the delivered report were
       // coverage/gap prose, and NOTHING governed it: the code-stamped `coverage_line:` front-matter
       // (scope-facts.mjs,) is EXCLUDED from predelivery-lint's prose scan by design
-      // (stripFrontMatterBlock, predelivery-lint.mjs:374), so a coverage number re-typed into prose
+      // (stripFrontMatterBlock, predelivery-lint.mjs:376), so a coverage number re-typed into prose
       // beside it is caught only if the prose form itself trips SCOPE_NUMBER_RE — which the narrative's
       // own phrasings routinely dodge. Prompt-only per §7; the fix is to stop authoring the duplicate.
       `COVERAGE PROSE (the lane that runs longest — hold it to the house budgets): the register coverage line a reader sees is COMPUTED from this run's own record and STAMPED BY CODE as front-matter (the proportion, the class states, the searched registers). Do NOT re-type its numbers anywhere in prose — not in a coverage[] note, not in the coverage_judgment reason, not in the narrative. Nothing catches the duplicate for you (the code-stamped line sits outside the prose checks precisely because ITS numbers are the authoritative ones), so a re-typed count does not disagree with the record — it silently drifts from it a redelivery later. Carry the SUBSTANCE and drop the number: "the remaining forms are non-Latin script" says the useful half; the code says how many. State each coverage fact ONCE, in ONE place — an area's state belongs in its coverage[] row, the sufficiency read belongs in coverage_judgment.reason, and neither is re-narrated in the other or in the findings. And say WHICH KIND of negative you hold every time: a source this run actually queried and got nothing from reads "searched — none found"; a source it did not reach reads "not searched this run" or "could not be searched — <the reason>". The same source must never wear both readings in one report.`,
@@ -4617,3 +4617,50 @@ export function whatsappRouting(job, agentId) {
     whatsappCcOperator: OPERATOR_WHATSAPP_COPY ? (AGENT_WHATSAPP[agentId] ?? null) : null,
   };
 }
+
+// ── A BUILDER THAT RAN AND SAID NOTHING SAYS SO, AND SAYS WHICH NOTHING ────────────────────────────
+//
+// AT THE FOOT OF THE FILE ON PURPOSE, and not because it belongs here. It belongs beside
+// `dispatchBlockState`, which is where a reader will look for it. Sixty-one line citations elsewhere in
+// the tree point INTO this file by number, and inserting twenty-three lines near the top moved every one
+// of them — three onto blank lines, where a guard caught them, and the rest onto real code, where one
+// guard could not see them and a second one could. Repointing them then rewrote their lines, which put
+// fifty-four pre-existing bare citations on the ADDED side of the diff and failed the check that refuses
+// newly-added ones. Appending costs a reader one jump; shifting costs the tree ninety-four citations and
+// two guards' worth of churn. The same reasoning is written up on the export tagging in bin/onboard.mjs.
+//
+// The receipt used to record a builder only when it produced text. An empty return landed in neither
+// list, so "this run had nothing to flag" and "this builder never ran" were the same reading — and the
+// second is a defect while the first is an ordinary run. Found in review on the narrative refutation
+// block: it reached its stage with flags and the stage rewrote none, and the receipt could not be used
+// to tell that apart from a block that never built.
+//
+// TWO EMPTIES, NOT ONE, because collapsing them repeats the fault one size down. A builder that read the
+// record and found nothing to flag has made a NEGATIVE FINDING; a builder whose source file was not
+// there has not looked at all. A single `empty` class would make "no flags over forty visible lines"
+// indistinguishable from "there was no record to open". So a builder returns one of these rather than a
+// bare "", and a bare "" from a builder nobody has taught to discriminate is recorded as exactly that —
+// unstated — rather than being counted as either.
+export const nothingFound = (why) => ({ dispatchEmpty: "nothing-found", why: String(why) });
+export const nothingToRead = (why) => ({ dispatchEmpty: "nothing-to-read", why: String(why) });
+
+/** The sentinel a builder returned, or null when it returned something else. PURE. */
+export const emptyReturn = (v) =>
+  (v && typeof v === "object" && typeof v.dispatchEmpty === "string" && typeof v.why === "string" ? v : null);
+
+/**
+ * Sort one builder's return into the three lists the receipt carries. Mutates the arrays it is given,
+ * which is what keeps its caller two lines long — and its caller is inside a file whose line numbers
+ * thirty-three citations depend on.
+ */
+export function recordEmptyReturn(built, id, { parts, ids, empty }) {
+  const said = emptyReturn(built);
+  if (said) empty.push({ id, kind: said.dispatchEmpty, why: said.why });
+  else if (typeof built === "string" && built) { parts.push(built); ids.push({ id, chars: built.length }); }
+  else empty.push({ id, kind: "empty-unstated", why: "the builder returned nothing and named no reason" });
+}
+
+/** Why a builder that ran produced nothing — its own sentence, or null when it is not in that state. PURE. */
+export function dispatchBlockWhy(ctx, stage, id) {
+  return ctx?.dispatchBlocks?.[stage]?.empty?.find((x) => x.id === id)?.why ?? null;
+}