clearotron 0.4.1-beta.5 → 0.4.1

package/driver/pipeline.mjs

@@ -78,7 +78,7 @@ import { armCoverageForm, coverageFormInput, coverageFormPaths, coverageFormStam
 import { releasedFamilyQids, readWithheldFamilies } from "./withheld-families.mjs";   // the waiting families the reading turn released join as dictated entries
 import { unionPlacementForm } from "./placement-union.mjs";
 import { readPlacementForm, readPlacementFormInput, writePlacementForm } from "./placement-form-io.mjs";
-import { buildSelectionIndex, setAsideGrounds, setAsideKeysOf, ownerFates } from "./placement-form.mjs";
+import { buildSelectionIndex, setAsideGrounds, setAsideKeysOf, ownerFates, isSetAsideGroupRow } from "./placement-form.mjs";
 import { dictatedPaths, findStrayArtifacts, treeSnapshot, findStrayInTree, matterSiblings, findStrayMatterSiblings } from "./stray-artifacts.mjs";   // — a run dir holds no document no stage dictated; — nor does the doctrine tree
 import { resolveProfile, resolveEffectiveProfile, derivedFloor, derivedBatchSize, gridBatchFor, applicantMatchesProfile, NEUTRAL_DELIVERY, deliveryForRun, recipeProseGuard, withRunPlatforms, profileStoreResolution } from "./profiles.mjs";   // adds profileStoreResolution — the CONFIG store's identity, beside the doctrine tree's
 import { resolveSearchPolicy, gateResolvedPolicy, loadRecipes, policyFor, isRegisterOnly, reportIdentityFor, depthFor } from "./search-policy.mjs";
@@ -2847,22 +2847,12 @@ export function deriveFloorDuty(ctx, r, trigger = null) {   // @internal — dri
     return null;
   };
   try {
-    if (!existsSync(P.bandShape)) return notComputable("no band-shape.json — the floors are not on disk to check against");
-    if (!existsSync(P.placementModel)) return notComputable("no placements.json (a run predating the structured placement mirror)");
-    let floors, placements;
-    try {
-      const shape = JSON.parse(readFileSync(P.bandShape, "utf8"));
-      // ABSENT vs EMPTY, and they are not the same answer. A shape with no floors slice cannot be
-      // reconciled and says so; a shape whose floors slice IS empty is a real answer — this band held no
-      // live in-class identical record — and reconciles trivially at 0/0.
-      const slice = shape?.floors?.in_class_identical_or_near;
-      if (!Array.isArray(slice)) return notComputable("band-shape.json carries no floors.in_class_identical_or_near array");
-      floors = slice;
-    } catch (e) { return notComputable(`band-shape.json unreadable: ${String(e?.message ?? e).slice(0, 80)}`); }
-    try { placements = parsePlacementsJson(readFileSync(P.placementModel, "utf8")).placements; }
-    catch (e) { return notComputable(`placements.json unparseable: ${String(e?.message ?? e).slice(0, 80)}`); }
-    const artifact = reconcileFloorDuty({ floors, placements, setAsideGroundOf: placementSetAsideGrounds(P) });
-    artifact.owners = placementOwnerFates(P, placements);
+    const now = floorDutyNow(P);
+    if (now.reason) return notComputable(now.reason);
+    const { artifact, placements } = now;
+    const fates = placementOwnerFates(P, placements);
+    artifact.owners = fates.counted ?? null;
+    if (!fates.counted) artifact.owners_absent = fates.absent;   // no count, and why: no groups, or an input that would not read
     // The pass's own outcome, beside the rows. That lesson: a stage that failed or skipped makes every
     // record it did not reach an UPSTREAM ABSENCE, not a judgment, and a reader blaming the seat for a
     // crash is reading the artifact wrong.
@@ -2885,6 +2875,42 @@ export function deriveFloorDuty(ctx, r, trigger = null) {   // @internal — dri
   }
 }
 
+/**
+ * The floors reconciled against the band shape and the placements now on disk: `{artifact, placements}`, or
+ * `{reason}` when they cannot be. Read, never written: `deriveFloorDuty` writes a pass's account from it, and a
+ * resumed run's skip reads it (`floorDutyOwedNow`).
+ */
+function floorDutyNow(P) {
+  const notComputable = (reason) => ({ reason });
+  if (!existsSync(P.bandShape)) return notComputable("no band-shape.json — the floors are not on disk to check against");
+  if (!existsSync(P.placementModel)) return notComputable("no placements.json (a run predating the structured placement mirror)");
+  let floors, placements;
+  try {
+    const shape = JSON.parse(readFileSync(P.bandShape, "utf8"));
+    // ABSENT vs EMPTY, and they are not the same answer. A shape with no floors slice cannot be
+    // reconciled and says so; a shape whose floors slice IS empty is a real answer — this band held no
+    // live in-class identical record — and reconciles trivially at 0/0.
+    const slice = shape?.floors?.in_class_identical_or_near;
+    if (!Array.isArray(slice)) return notComputable("band-shape.json carries no floors.in_class_identical_or_near array");
+    floors = slice;
+  } catch (e) { return notComputable(`band-shape.json unreadable: ${String(e?.message ?? e).slice(0, 80)}`); }
+  try { placements = parsePlacementsJson(readFileSync(P.placementModel, "utf8")).placements; }
+  catch (e) { return notComputable(`placements.json unparseable: ${String(e?.message ?? e).slice(0, 80)}`); }
+  return { artifact: reconcileFloorDuty({ floors, placements, setAsideGroundOf: placementSetAsideGrounds(P) }), placements };
+}
+
+/**
+ * DOES PLACEMENT OWE FLOORS ON THE SHAPE NOW ON DISK? A resumed run derives the band shape afresh, and one derived
+ * since the last placement pass can owe more than that pass's floor-duty artifact says: a floor the new shape adds,
+ * or a crowded (b) whose row no longer stands. Read from the artifact alone, placement skipped, the duty was derived
+ * again straight after it, and the report shipped clamped with the step never asked. Read here as well, placement
+ * runs again, and its dispatch-time union tells the step what changed. False where nothing can be reconciled.
+ */
+export function floorDutyOwedNow(P, name) {   // @internal — driven by its test with a run's own files
+  if (name !== "placement-inquiry" || !floorDutyArmed(P.runDir)) return false;
+  try { return Boolean(floorDutyBlock(floorDutyNow(P).artifact, { armed: true })); } catch { return false; }
+}
+
 function derivePlacementCarry(ctx, trigger) {
   const P = ctx.paths;
   const write = (artifact) => {
@@ -3008,24 +3034,44 @@ function recordPlacementSeam(ctx, r, trigger = null) {
   });
 }
 
+/**
+ * The form's set-aside entries as they stand on the shape now on disk. A ground by name stands as stored. A
+ * group's row is checked again exactly as the union took it, on its count and on every line read, because the
+ * shape may have been derived again since: a resumed run derives it afresh, and a record body fetched after
+ * placement can move a line out of the list the goods test could not place and into a group. A row taken on
+ * the earlier shape then covers no line the later one added. Nothing is written back. PURE.
+ */
+function standingSetAside(entries, input) {
+  const all = Array.isArray(entries) ? entries : [];
+  const grouped = all.filter(isSetAsideGroupRow);
+  if (!grouped.length) return all;
+  const { form } = unionPlacementForm({ rows: [], set_aside: grouped }, null, input);
+  return [...all.filter((e) => !isSetAsideGroupRow(e)), ...form.set_aside_groups];
+}
+
 /** The set-aside grounds the placement form holds, by name and by group, as uri → entry, through the form's own selection index. */
-function placementSetAsideGrounds(P) {
+export function placementSetAsideGrounds(P) {   // @internal — driven by its test with a run's own files
   try {
     const form = readPlacementForm(P.runDir);
     if (!form.set_aside?.length) return () => null;
     const input = readPlacementFormInput(P.runDir);
-    return setAsideGrounds(form.set_aside, buildSelectionIndex(input), input.groups, input.floors);
+    return setAsideGrounds(standingSetAside(form.set_aside, input), buildSelectionIndex(input), input.groups, input.floors);
   } catch { return () => null; }
 }
 
-/** Every owner's fate at placement, by the shape's lists (placement-form.mjs `ownerFates`); null when the shape has no groups. */
-function placementOwnerFates(P, placements) {
+/**
+ * Every owner's fate at placement, by the shape's lists (placement-form.mjs `ownerFates`): `{counted}`, or `{absent}`
+ * saying why there is no count. A shape with no groups has nothing to count by; an input that would not read is a
+ * gap in the record. The two are not one fact, and the floor duty's artifact keeps them apart.
+ */
+export function placementOwnerFates(P, placements) {   // @internal — driven by its test with a run's own files
   try {
     const input = readPlacementFormInput(P.runDir);
-    if (!input.groups) return null;
-    return ownerFates({ groups: input.groups, entries: readPlacementForm(P.runDir).set_aside, index: buildSelectionIndex(input),
+    if (!input.groups) return { absent: "the band shape lists no groups" };
+    const counted = ownerFates({ groups: input.groups, entries: standingSetAside(readPlacementForm(P.runDir).set_aside, input), index: buildSelectionIndex(input),
       placedUris: (Array.isArray(placements) ? placements : []).flatMap((p) => (Array.isArray(p?.records) ? p.records : [])) });
-  } catch { return null; }
+    return counted ? { counted } : { absent: "the band shape's groups could not be counted" };
+  } catch (e) { return { absent: `an input could not be read: ${String(e?.message ?? e).slice(0, 120)}` }; }
 }
 
 /**
@@ -4428,7 +4474,7 @@ async function stageOnce(name, ctx, opts = {}) {
   // undischargeable and the run spent every remaining stage travelling toward a failure it was already
   // doomed to. Reconciled toward the stricter side — the predicate lives in floor-duty.mjs and is CALLED,
   // never copied, so the two judgements cannot drift apart again.
-  const dutyBlocksSkip = !forced && floorDutyBlocksSkip(P.runDir, name);
+  const dutyBlocksSkip = !forced && (floorDutyBlocksSkip(P.runDir, name) || floorDutyOwedNow(P, name));
   if (dutyBlocksSkip) {
     note(`[${label}] NOT skipped — its floor duty is undischarged, so its output is not valid to reuse; `
       + "re-running so the seat can place the outstanding floor(s) or name them with a ground "
@@ -10876,12 +10922,14 @@ async function pipelineInner(job, opts = {}) {
         // (`x:0` vs `x:null` must differ by value, never by presence). The demote paths carry the SAME
         // rows forward unchanged, deliberately — a failed re-digest demotes CLOSURE, not searchedness:
         // a query that ran still ran.
-        const writeReopenReceipt = (swept, deferrals, dom, partials = [], accounting = null) => {
+        const writeReopenReceipt = (swept, deferrals, dom, partials = [], accounting = null, answered = []) => {
           try {
             writeFileSync(reopenReceiptPath, JSON.stringify({
               ts: new Date().toISOString(), requested: firing.map(reopenKey),
               swept, deferrals, remaining: deferrals.map((x) => x.directive),
               ...(partials.length ? { partials } : {}),
+              // a closed directive whose slice the fold refused as already-asked, with the plan row that answered it
+              ...(answered.length ? { answered_elsewhere: answered } : {}),
               dominant_element_gap, domClosed: dom,
               directive_qids: reopenQids, born: reopenBorn,
               remedy_terms: accounting?.computable === true ? accounting.rows : null,
@@ -10927,6 +10975,7 @@ async function pipelineInner(job, opts = {}) {
           // minted subset — the refusal is disclosed per directive (receipt `partials` row on a close,
           // folded into the defer reason otherwise), never dropped into the aggregate count alone.
           const regPartialMint = new Map();
+          const regAnsweredBy = new Map();   // reopenKey → the plan rows that answered its slices the fold refused as already-asked
           // — the per-TERM rows the remedy ledger accounts. One row per remedy term per directive,
           // recorded at the mint seam (the only place the term→qid mapping exists) so the receipt can
           // later say what each term asked and what came back. reopenKey → [{term, predicates, qids,
@@ -11086,10 +11135,16 @@ async function pipelineInner(job, opts = {}) {
                 const blocksByQid = new Map((bands[a] ?? []).filter((b) => b && b.qid).map((b) => [b.qid, b]));
                 return { outcome, executedQids, blocksByQid };
               };
-              const verifyOne = (d, ev) => verifyRegisterDirectiveClose({
-                qids: directiveQids.get(reopenKey(d)) ?? [], intendedClasses: directiveIntended.get(reopenKey(d)) ?? [],
-                executedQids: ev.executedQids, blocksByQid: ev.blocksByQid,
-              });
+              // A slice the fold refused as already-asked is checked on the row that answered it, as the remedy
+              // term ledger reads it; the directive it closes names that row in the receipt.
+              const verifyOne = (d, ev) => {
+                const v = verifyRegisterDirectiveClose({
+                  qids: directiveQids.get(reopenKey(d)) ?? [], intendedClasses: directiveIntended.get(reopenKey(d)) ?? [],
+                  executedQids: ev.executedQids, blocksByQid: ev.blocksByQid, foldRefusals: regFoldRefusals,
+                });
+                if (v.closed && v.answered_by) regAnsweredBy.set(reopenKey(d), v.answered_by);
+                return v;
+              };
               const mintedDirectives = regDirectives.filter((d) => (directiveQids.get(reopenKey(d)) ?? []).length);
               let ev = await dispatchAndVerify(added);
               regLastJoin = ev;
@@ -11430,7 +11485,8 @@ async function pipelineInner(job, opts = {}) {
           // ending states "closed on N of M remedy proposals; K refused: <reason>", never a bare close.
           const partials = swept.filter((k) => regPartialMint.has(k))
             .map((k) => ({ directive: k, note: `verified-closed on the minted subset — ${regPartialMint.get(k)}` }));
-          writeReopenReceipt(swept, deferrals, domClosed, partials, remedyAccounting);
+          const answered = swept.filter((k) => regAnsweredBy.has(k)).map((k) => ({ directive: k, slices: regAnsweredBy.get(k) }));
+          writeReopenReceipt(swept, deferrals, domClosed, partials, remedyAccounting, answered);
           runLog(run.runDir, { event: "frame-reopen", requested: firing.length, swept: swept.length, deferred: deferrals.length, remaining: deferrals.length, dominant_element_gap, domClosed, reopenFetchCap: regDirectives.some((d) => d.severity === "dominant-element") ? reopenFetchCap : undefined });
           // C2 (review fix, 2026-07-29) — the redigest-fail demotion invariant, LOCKED path. The
           // unlocked path demotes verified-closed directives inline when its pre-synthesis flush

package/driver/predelivery-lint.mjs

@@ -2358,7 +2358,7 @@ export function runLint({ depth, commonLawGrid, matterContext, clientPartyName,
 //   prescription-prose
 // Everything else is ABSENT BY DESIGN and says so in the receipt (KNOCKOUT_ABSENT_BY_DESIGN below) —
 // never an entry that silently passes, which is the failure mode this tranche exists to kill. Measured
-// against two real archived knockout runs (2026-07-28 BRIMSTONE, 2026-07-29 TASTICLES): zero flags on the
+// against two archived knockout runs, from 2026-07-28 and 2026-07-29: zero flags on the
 // applicable five, and templateChecks false-FAILED names-cell-populated on both (there is no NAME(S)
 // row on this lane) — which is why it is excluded rather than run.
 //

package/driver/record-goods.mjs

@@ -96,6 +96,36 @@ export function recordGoods(body, { english = true } = {}) {
   return out;
 }
 
+// THE RAW GOODS LIST SAYS NOTHING THE NORMALISED ONE DOES NOT. A Clarivate record holds its goods twice: as the
+// register wrote them (`_raw.goodsServices.intClassDescriptions`) and as the provider maps them, item for item,
+// into `goodsServices` beside it (providers/clarivate/src/core.js `normalizeGoodsServices`). On a crowded test
+// run, 2026-10-13, the raw goods were 22.7 of the 53.5 MB of record text, and all 1,348 records held both
+// lists. Only the five fields that mapping reads are known here: a raw item carrying any other field, classes
+// written other than as numbers between commas (one statement may cover several classes: "9,35,42"), or any
+// value the normalised item does not repeat exactly means the raw list says something of its own. The rest of
+// the raw goods block (a national class list, on six of those records) is not the normalised list's to carry.
+const RAW_GOODS_FIELDS = new Set(["intClassNumber", "intGoodsLanguageCode", "intGoodsServicesDescription",
+  "cmComputerTranslationIntGoodsLanguageCode", "cmComputerTranslationIntGoodsServicesDescription"]);
+
+/** Does the record's `goodsServices` carry its raw international goods list item for item, so that list adds nothing? PURE. */
+export function rawGoodsCarried(body) {
+  const items = body?._raw?.goodsServices?.intClassDescriptions, norm = body?.goodsServices;
+  if (!Array.isArray(items) || !items.length || !Array.isArray(norm) || norm.length !== items.length) return false;
+  return items.every((d, i) => {
+    const n = norm[i];
+    if (!d || typeof d !== "object" || Array.isArray(d) || !n || typeof n !== "object") return false;
+    if (Object.keys(d).some((k) => !RAW_GOODS_FIELDS.has(k))) return false;
+    const cls = String(d.intClassNumber ?? "").trim();
+    if (cls !== "" && !/^\d+(\s*,\s*\d+)*$/.test(cls)) return false;
+    const classes = cls === "" ? [] : cls.split(",").map((c) => Number(c.trim()));
+    const same = (a, b) => (a ?? null) === (b ?? null);
+    return Array.isArray(n.classes) && n.classes.length === classes.length && n.classes.every((c, j) => c === classes[j])
+      && same(d.intGoodsLanguageCode, n.language) && same(d.intGoodsServicesDescription, n.description)
+      && same(d.cmComputerTranslationIntGoodsLanguageCode, n.translation_language)
+      && same(d.cmComputerTranslationIntGoodsServicesDescription, n.translation);
+  });
+}
+
 /**
  * Every record's goods this run holds, by canonical record uri: Map(uri → [{classes, text}]). Read from the
  * record ledger, then from `_records/`, the later copy of a record winning, as `band_record` reads them. A

package/driver/remedy-accounting.mjs

@@ -42,7 +42,7 @@
 // re-stated: verifyRegisterDirectiveClose asks the identical question of the same blocks, and two
 // copies of a matcher is how two matchers drift apart.
 
-import { blockCollapsed } from "./close-verify.mjs";
+import { blockCollapsed, answeredAs } from "./close-verify.mjs";
 import { reopenKey } from "./frame-diff-model.mjs";
 
 export const REMEDY_ACCOUNTING_SCHEMA_VERSION = 1;
@@ -158,11 +158,7 @@ export function classifyRemedyTerm(row, { blocksByQid = new Map(), executedQids
   //
   // ONLY THE DUPLICATE KIND RESOLVES. An identity collision or a malformed term is a genuine fault and
   // stays `dispatch-failed`: nothing else asked those questions, so nothing else answers them.
-  const resolve = (q) => {
-    const r = foldRefusals.get?.(q);
-    return r && r.kind === "duplicate-question" && r.twin ? String(r.twin) : q;
-  };
-  const landsAs = new Map(qids.map((q) => [q, resolve(q)]));
+  const landsAs = new Map(qids.map((q) => [q, answeredAs(q, foldRefusals)]));   // one rule with the directive check
   const blockFor = (q) => blocksByQid.get(landsAs.get(q) ?? q);
   const ranAs = (q) => executedQids.has(landsAs.get(q) ?? q);
   const slices = qids.map((q) => {

package/driver/skills/knockout-assess/SKILL.md

@@ -59,8 +59,8 @@ there is no other value: a band that needs sharpening is the band above it, stat
    known-to-enforce rights holders" — is RETIRED. That is owner size and fame driving a band, which the
    framework decks forbid in terms: "Optics — owner size, fame, partnership — never move the legal
    read." It was the only instruction in this seat's context licensing that move, and the readiest
-   explanation for a Disney hit rating Very High and an EA hit rating High against a lawyer's Medium and
-   Manageable. The rest of the rule stands and is doctrine.)*
+   explanation for a famous owner's hit rated well above the lawyer's grade. The rest of the rule stands
+   and is doctrine.)*
 3. **RETIRED — how ordinary the words are is a note for the reviewing lawyer, never a band.**
    This forbade the lowest band for a common English phrase and put a floor a band above it. On a
    scale that ends in Low it kept an everyday name off "no issues found"; on a client scale with no

package/driver/stages-knockout.mjs

@@ -467,19 +467,6 @@ export const KO_STAGES = {
       // the same run had taken. The turn was not lying: it is never shown the count lane's output (rule 1
       // of register-count.mjs) and it filled the gap with the only thing it had. Nobody who cannot see
       // the machinery describes it — the renderer owns that sentence and writes it from the sidecars.
-      // ── THE GAG SPLITS: THE LANE STAYS GAGGED, THE FILINGS DO NOT ─────────────────────────────────
-      //
-      // The rule below is about COVERAGE — whether the register lane ran, how much it found, how far it
-      // reached. That stays, and its reason is unchanged: this seat cannot see that lane, the report
-      // states coverage in code from the run's own measurements, and a summary saying the registers were
-      // not run above a table of counts that were is the contradiction it closes.
-      //
-      // What it must NOT be read as, and was: a bar on weighing an individual filing you were handed.
-      // The validator arm behind it (`REGISTER_CLAIM_RE`) is KEPT and is already scoped correctly —
-      // driven on seven sentences, it matches all three coverage narrations and none of four weighing
-      // sentences ("Disney holds a Hong Kong registration…", "the German registration is vulnerable to
-      // non-use revocation…"). The issue asked for the arm to be deleted; deleting it would remove
-      // exactly the protection the issue's own next sentence says to keep. Measured, raised, kept.
       `SAY NOTHING ABOUT WHETHER THE REGISTER LANE RAN — whether registers were searched, counted,`,
       `overlaid or checked, how many filings exist, or how far the search reached. Not in any field, not`,
       `in the chunk summary. You cannot see that lane; the report states its coverage in code from the`,

package/driver/stages.mjs

@@ -2610,7 +2610,7 @@ export const STAGES = {
       `Adopt or override each placement BY ENGAGING ITS reason — an override quotes the reason it contradicts (never silently re-tiers), and a kept tier may still tighten a label while reusing the reason. On a corrective/repair pass, do NOT re-read the whole placement file: the tiers are in ${P.placementModel}, and the md's rulings tail is handed to you verbatim in this dispatch (the PLACEMENT RULINGS TAIL block) — adjudicate against it there.`,
       // judgment-relocation (2026-06-23): the COMPLETE named band — run the relevance gate over the REAL
       // material. PR-8: read via the band tools (shape whole + logged lookups), never by slicing the raw file.
-      BAND_READING_CONTRACT,
+      BAND_READING_CONTRACT_AFTER_PLACEMENT,
       `Reconcile your Coverage ledger against the shape's crowd descriptors: an `+"`incomplete`"+` slice is an open crowd the lawyer must weigh (a count-only / unenumerable slice), never a clean.`,
       // P2-A (charter P2d): identity collapse is CODE-derived before you read — the shape's Positions
       // section (and _driver/register-positions.json) is the exact-identity projection. "Owner
@@ -3198,7 +3198,7 @@ export const STAGES = {
       // dangerous named band or reported HONEST INCOMPLETENESS; you read the complete material and decide
       // relevance, risk, sufficiency and prioritisation. PR-8: the reading goes through the band tools
       // (shape whole + logged lookups) — nothing was sampled away upstream, and nothing is sliced by hand.
-      BAND_READING_CONTRACT,
+      BAND_READING_CONTRACT_AFTER_PLACEMENT,
       // PR-8: synthesis holds NO live register tools — by design, never an outage. The funnel owns
       // enumeration; a register check this stage still wants is either answerable from the frozen
       // material (the band tools) or it is NEW SEARCH WORK, which enters only through the supplemental
@@ -4749,6 +4749,15 @@ export function dispatchBlockWhy(ctx, stage, id) {
 // onto a different real line passes while describing the wrong code. Adding below the last cited line
 // is the one placement that cannot do that. See band-size.mjs for what reads this.
 export const BAND_READING_STAGES = new Set(["placement-inquiry", "register-digest", "synthesis"]);
+// THE STAGE THAT OWES THE SHAPE'S GROUPS THEIR FATES, and so the only one offered `band_lookup`'s group pages.
+// Every line a group lists gets a fate at placement; no other stage owes the band a read, and a synthesis that
+// was handed the same offer paged an exhausted group 2,498 times (measured on a test run, 2026-10-13).
+export const GROUP_READING_STAGES = new Set(["placement-inquiry"]);
+// The contract as the stages after placement read it: without "Every floor has a fate on the form.", which is an
+// order to placement, whose form it names. The digest and synthesis owe no floor a fate (Krzys's ruling,
+// 2026-10-14). Removed from the one contract, never restated, so the two cannot drift apart.
+export const FLOOR_FATE_ORDER = "Every floor has a fate on the form.";
+export const BAND_READING_CONTRACT_AFTER_PLACEMENT = BAND_READING_CONTRACT.replace(` ${FLOOR_FATE_ORDER}`, "");
 
 // The register reading step's order on the waiting families. One constant, because the cross-check
 // follow-up reads it word for word (repair-composers.mjs); declared last so no line above it moves.

package/driver/suite-census.json

@@ -185,7 +185,7 @@
         },
         "a-childs-output-is-decoded-as-a-stream.test.mjs": {
           "tests": 3,
-          "asserts": 10,
+          "asserts": 14,
           "skips": 1,
           "todos": 0
         },
@@ -249,6 +249,12 @@
           "skips": 1,
           "todos": 0
         },
+        "a-codex-stage-runs-without-the-sign-ins-apps.test.mjs": {
+          "tests": 1,
+          "asserts": 5,
+          "skips": 0,
+          "todos": 0
+        },
         "a-command-printed-from-npx-outlives-the-cache.test.mjs": {
           "tests": 3,
           "asserts": 14,
@@ -657,6 +663,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-group-row-covers-no-line-a-later-shape-added.test.mjs": {
+          "tests": 4,
+          "asserts": 16,
+          "skips": 0,
+          "todos": 0
+        },
         "a-group-row-covers-only-the-lines-it-was-shown.test.mjs": {
           "tests": 13,
           "asserts": 41,
@@ -777,6 +789,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-knockout-refusal-is-routed-as-the-knockout-records.test.mjs": {
+          "tests": 2,
+          "asserts": 6,
+          "skips": 0,
+          "todos": 0
+        },
         "a-knockout-run-with-no-method-is-not-offered-inputs.test.mjs": {
           "tests": 2,
           "asserts": 5,
@@ -909,6 +927,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-missing-fate-count-says-why.test.mjs": {
+          "tests": 3,
+          "asserts": 7,
+          "skips": 0,
+          "todos": 0
+        },
         "a-mixed-alphabet-look-alike-is-not-sent-where-the-register-drops-its-letters.test.mjs": {
           "tests": 10,
           "asserts": 46,
@@ -921,6 +945,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-name-above-its-cards-is-refused-where-the-model-can-fix-it.test.mjs": {
+          "tests": 3,
+          "asserts": 6,
+          "skips": 0,
+          "todos": 0
+        },
         "a-name-documented-in-any-example-file-is-documented.test.mjs": {
           "tests": 7,
           "asserts": 16,
@@ -1113,6 +1143,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-question-the-plan-already-asked-closes-its-directive.test.mjs": {
+          "tests": 6,
+          "asserts": 13,
+          "skips": 0,
+          "todos": 0
+        },
         "a-queued-job-is-visible-before-a-worker-claims-it.test.mjs": {
           "tests": 6,
           "asserts": 16,
@@ -1179,6 +1215,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-records-goods-are-served-once.test.mjs": {
+          "tests": 6,
+          "asserts": 19,
+          "skips": 0,
+          "todos": 0
+        },
         "a-refusal-is-not-a-pass.test.mjs": {
           "tests": 6,
           "asserts": 10,
@@ -1335,6 +1377,12 @@
           "skips": 0,
           "todos": 0
         },
+        "a-resumed-run-asks-the-step-when-the-shape-moved.test.mjs": {
+          "tests": 3,
+          "asserts": 13,
+          "skips": 0,
+          "todos": 0
+        },
         "a-retrieval-group-does-not-vote-on-seat-writes.test.mjs": {
           "tests": 5,
           "asserts": 15,
@@ -1923,6 +1971,12 @@
           "skips": 0,
           "todos": 0
         },
+        "an-engines-output-is-decoded-as-a-stream.test.mjs": {
+          "tests": 2,
+          "asserts": 3,
+          "skips": 0,
+          "todos": 0
+        },
         "an-environment-read-through-optional-chaining-is-a-read.test.mjs": {
           "tests": 6,
           "asserts": 19,
@@ -4197,6 +4251,12 @@
           "skips": 0,
           "todos": 0
         },
+        "placements-orders-reach-placement-alone.test.mjs": {
+          "tests": 2,
+          "asserts": 11,
+          "skips": 0,
+          "todos": 0
+        },
         "plain-words-on-what-the-reader-sees-first.test.mjs": {
           "tests": 20,
           "asserts": 50,
@@ -6009,6 +6069,12 @@
           "skips": 0,
           "todos": 0
         },
+        "the-group-filter-is-offered-to-placement-alone.test.mjs": {
+          "tests": 2,
+          "asserts": 14,
+          "skips": 0,
+          "todos": 0
+        },
         "the-heartbeat-stays-fresh-while-a-run-is-in-flight.test.mjs": {
           "tests": 4,
           "asserts": 8,
@@ -6099,6 +6165,12 @@
           "skips": 0,
           "todos": 0
         },
+        "the-knockout-review-meets-the-tone-and-figure-checks.test.mjs": {
+          "tests": 2,
+          "asserts": 5,
+          "skips": 0,
+          "todos": 0
+        },
         "the-knockout-reviewing-pass-rewrites-what-a-reader-sees-first.test.mjs": {
           "tests": 21,
           "asserts": 80,
@@ -7179,8 +7251,8 @@
           "todos": 0
         },
         "events.test.mjs": {
-          "tests": 7,
-          "asserts": 26,
+          "tests": 9,
+          "asserts": 31,
           "skips": 0,
           "todos": 0
         },
@@ -7346,6 +7418,12 @@
           "skips": 0,
           "todos": 0
         },
+        "the-knockout-stage-notes-match-the-pipeline.test.mjs": {
+          "tests": 2,
+          "asserts": 5,
+          "skips": 0,
+          "todos": 0
+        },
         "the-package-starts-the-mcp-server.test.mjs": {
           "tests": 6,
           "asserts": 22,

package/driver/verify-knockout.mjs

@@ -626,18 +626,15 @@ export const validators = {
       // fields are the sentences a reader now sees FIRST, so a banned tone or a fabricated quantity in
       // `basis` reaches the page ahead of anything in `bullets`. A check whose span stops short of the
       // most prominent prose on the card is a check that stopped working the day the card changed.
-      const prose = [m.contextFraming, m.basis, ...(m.factors ?? []), ...(m.counterFactors ?? []), m.mitigation,
-        ...(m.bullets ?? []), ...(m.purpleNotes ?? []), m.registerEstimate].filter(Boolean).join("\n");
+      const prose = markProse(m);
       // — the model may not speak for the register lane. Checked over the mark's whole prose and
       // over this chunk's summary: the live defect was in the summary, and the fields are new surface
       // for exactly the same invention.
       const claim = [prose, c.chunkSummary].filter(Boolean).join("\n").match(REGISTER_CLAIM_RE);
       if (claim)
         return { ok: false, reason: `knockout_register_claim:${m.name}: "${claim[0].trim()}" — this turn cannot see the register lane and must not describe it. The report states register coverage in code, from the run's own count sidecar; a summary that says the registers were not run, above a table of counts that were, is the contradiction this rule closes. Delete the clause` };
-      const banned = prose.match(BANNED_TONE_RE);
-      if (banned) return { ok: false, reason: `mark "${m.name}": banned tone "${banned[0]}" — measured tone only (the band colour carries urgency)` };
-      const quant = prose.match(QUANT_CLAIM_RE);
-      if (quant) return { ok: false, reason: `mark "${m.name}": quantitative claim "${quant[0].trim()}" — describe nature and reach, never counts/figures` };
+      const toneOrFigure = toneOrFigureRefusal(m, prose);
+      if (toneOrFigure) return { ok: false, reason: toneOrFigure };
       // PR-5 — a "tool was blocked / lacked permission" explanation for missing coverage is a false
       // excuse on this lane too (register work is a PENDING framing here, never an outage story). Fires
       // in the chunk validator so the corrective ladder re-asks THIS chunk with the quoted lines.
@@ -656,6 +653,12 @@ export const validators = {
       // artifact (validateMergedFindings below), which is the object every surface renders from.
       try { validateKnockoutFindings(m.findings, method === undefined ? { manifest: fw } : { manifest: fw, method }); }
       catch (e) { return { ok: false, reason: `mark "${m.name}": ${e.message}` }; }
+      // A NAME IS NEVER RATED ABOVE THE WORST CARD ON ITS PAGE, refused here as well as on the merged artifact.
+      // The merged gate's refusal fails the stage outside the corrective ladder, so the turn that could rate the
+      // name again never heard why, and the run went back to the register listing. Refused at the chunk, the
+      // same rule's own words reach this chunk's corrective turn. After the findings check, which settles bands.
+      const above = markRatedAboveItsCards(fw, m);
+      if (above) return { ok: false, reason: above };
       // URL-receipts gate: every cited URL ∈ that mark's raw payload (one function, three doors)
       const rec = knockoutReceipts(runDir, [m]);
       if (!rec.ok) return { ok: false, reason: rec.failures[0] };
@@ -724,6 +727,19 @@ export function raterCaveats(list) {
     .filter((c) => String(c ?? "").trim() && !isEngineAppendedCaveat(c));
 }
 
+/** A mark's prose as a reader meets it: every field the tone, figure and permission checks sweep. PURE. */
+const markProse = (m) => [m.contextFraming, m.basis, ...(m.factors ?? []), ...(m.counterFactors ?? []), m.mitigation,
+  ...(m.bullets ?? []), ...(m.purpleNotes ?? []), m.registerEstimate].filter(Boolean).join("\n");
+
+/** The banned-tone or quantity refusal for a mark's prose, in the chunk gate's own words; null when clean. PURE. */
+function toneOrFigureRefusal(m, prose = markProse(m)) {
+  const banned = prose.match(BANNED_TONE_RE);
+  if (banned) return `mark "${m.name}": banned tone "${banned[0]}" — measured tone only (the band colour carries urgency)`;
+  const quant = prose.match(QUANT_CLAIM_RE);
+  if (quant) return `mark "${m.name}": quantitative claim "${quant[0].trim()}" — describe nature and reach, never counts/figures`;
+  return null;
+}
+
 export function validateMergedFindings(runDir, merged, plan) {
   const failures = [];
   if (merged?.schema_version !== 1) failures.push("schema_version must be 1");
@@ -774,12 +790,13 @@ export function validateMergedFindings(runDir, merged, plan) {
   // each mark's contextFraming/bullets/purpleNotes/registerEstimate. It does NOT cover findings[].name /
   // .description, which the report renders onto the page; that span is picked up (as a FLAG, never a
   // refusal) by the publish-path lint added 2026-07-31.
-  const mergedProse = [String(merged?.batch?.executiveSummary ?? ""),
-    ...marks.map((m) => [m.contextFraming, m.basis, ...(m.factors ?? []), ...(m.counterFactors ?? []), m.mitigation,
-      ...(m.bullets ?? []), ...(m.purpleNotes ?? []), m.registerEstimate].filter(Boolean).join("\n")),
-  ].join("\n");
+  const mergedProse = [String(merged?.batch?.executiveSummary ?? ""), ...marks.map(markProse)].join("\n");
   for (const c of permissionProseChecks({ text: mergedProse, surface: "findings", idSuffix: ":knockout", structural: true, cards: false }).filter((x) => !x.pass))
     failures.push(c.detail);
+  // THE CHUNK GATE'S TONE AND FIGURE CHECKS, AGAIN ON WHAT SHIPS. The review's rewrites reach the record through
+  // this gate alone (pipeline-knockout.mjs), so a phrase or a figure the first pass would have refused is
+  // refused here too, in the same words, and the rated record stands.
+  for (const m of marks) { const toneOrFigure = toneOrFigureRefusal(m); if (toneOrFigure) failures.push(toneOrFigure); }
   // backstop, on the MERGED artifact — the same reason the permission check has one: a resume can
   // compose from chunk files written before this rule existed, and the register sentence is the one the
   // reader meets in the executive summary. The renderer owns register coverage; nothing else states it.

package/mcp-server/CHANGELOG.md

@@ -1,5 +1,13 @@
 # trademark-artifacts-mcp
 
+## 0.4.1
+
+No changes in this release.
+
+## 0.4.1-beta.6
+
+No changes in this release.
+
 ## 0.4.1-beta.5
 
 No changes in this release.

package/mcp-server/http-smoke.mjs

@@ -40,6 +40,7 @@ const child = spawn("node", [join(here, "http-server.mjs")], {
   env: { ...process.env, TRADEMARK_MCP_AUTH_DISABLED: "1", TRADEMARK_MCP_DEV: "1", TRADEMARK_MCP_HTTP_PORT: String(PORT), TRADEMARK_MCP_HTTP_HOST: "127.0.0.1", CLEAROTRON_ACCESS_FILE: grantsFile },
   stdio: ["ignore", "ignore", "pipe"],
 });
+child.stderr.setEncoding("utf8");
 child.stderr.on("data", (d) => process.stderr.write(`[server] ${d}`));
 
 let failed = false;
@@ -47,6 +48,7 @@ const ok = (cond, msg) => { console.log(`${cond ? "ok  " : "FAIL"} ${msg}`); if
 
 await new Promise((resolve, reject) => {
   const to = setTimeout(() => reject(new Error("http-server did not become ready in 8s")), 8000);
+  child.stderr.setEncoding("utf8");
   child.stderr.on("data", (d) => { if (String(d).includes("listening")) { clearTimeout(to); resolve(); } });
   child.on("exit", (c) => { clearTimeout(to); reject(new Error(`http-server exited early (${c})`)); });
 });