clearotron 0.5.0-beta.2 → 0.5.0-beta.3

package/driver/placement-decisions.mjs

@@ -13,7 +13,7 @@
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { createHash } from "node:crypto";
-import { buildSelectionIndex, setAsideGrounds, isSetAsideGroupRow, lineKey, groupName, servedLines } from "./placement-form.mjs";
+import { buildSelectionIndex, setAsideGrounds, isSetAsideGroupRow, lineKey, groupName, servedLines, FLOOR_GROUND_ON } from "./placement-form.mjs";
 import { unionPlacementForm } from "./placement-union.mjs";
 import { readPlacementForm, readPlacementFormInput } from "./placement-form-io.mjs";
 import { parsePlacementsJson } from "./placement-model.mjs";
@@ -78,7 +78,7 @@ export function placementSetAsideGrounds(P) {   // @internal — driven by its t
 
 /**
  * THE FLOORS PLACEMENT SET ASIDE, AS THE REVIEW IS TOLD THEM: one line per standing decision on the shape now on disk,
- * with placement's ground once. A set-aside by name, on its status or its territory, covers one floor and names it. A
+ * with placement's ground once. A set-aside by name, on its status, territory, goods or mark, covers one floor and names it. A
  * crowd's row names its ground once and then every floor it covers, by record: the ground is the group's, so it was
  * never the floors' to repeat, and on a test run of a crowded matter repeating it on each of 1,177 floors made the
  * review's opening message 866 KB of its 899. Only decisions that stand on the current shape are listed
@@ -99,7 +99,7 @@ export function placementFloorDecisionLines(P) {   // @internal — driven by it
         const key = `${g.group}\u0000${g.ground}`;
         if (!rows.has(key)) { rows.set(key, { group: g.group, ground: g.ground, ids: [] }); out.push(rows.get(key)); }
         rows.get(key).ids.push(f.record_id);
-      } else if (g.on === "status" || g.on === "territory") {
+      } else if (FLOOR_GROUND_ON.includes(g.on)) {
         out.push(`- ${f.mark_text ?? "(unnamed)"}${f.owner_name ? ` — ${f.owner_name}` : ""} (${f.record_id}): set aside on its ${g.on}: ${g.ground}`);
       }
     }
@@ -130,7 +130,7 @@ export function standingPlacementDecisions(P) {   // @internal — driven by its
         covered_lines_hash: createHash("sha256").update((e.covered_lines ?? []).join("\n")).digest("hex").slice(0, 16) }];
       const c = index.resolve(e.set_aside);
       return [{ kind: "name", record: e.set_aside, mark: c?.mark ?? null, owner: c?.owner ?? null, ground: e.ground,
-        ...(e.on === "status" || e.on === "territory" ? { on: e.on } : {}) }];
+        ...(FLOOR_GROUND_ON.includes(e.on) ? { on: e.on } : {}) }];
     });
   } catch { return []; }
 }

package/driver/placement-form-io.mjs

@@ -25,6 +25,7 @@ import { join, dirname, basename } from "node:path";
 import { driverDir } from "../shared/driver-dir.mjs";   //
 import { PLACEMENT_FORM_NAME, placementFormSidecarName, parsePlacementForm, renderPlacementsJson } from "./placement-form.mjs";
 import { parsePlacementsJson } from "./placement-model.mjs";
+import { normalizeRecordUri } from "./registry-fidelity.mjs";
 import { atomicWrite } from "./progress.mjs";
 
 export { PLACEMENT_FORM_NAME };
@@ -54,13 +55,32 @@ export function placementFormStamp(runDir) {
 export function readPlacementFormInput(runDir) {
   const shape = readJson(driverDir(runDir, "band-shape.json"));
   const pos = readJson(driverDir(runDir, "register-positions.json"));
-  return {
+  const scope = readJson(driverDir(runDir, "instructed-scope.json"));
+  const input = {
     floors: Array.isArray(shape?.floors?.in_class_identical_or_near) ? shape.floors.in_class_identical_or_near : null,
     positions: Array.isArray(pos?.positions) ? pos.positions : null,
     // The shape's groups, which a group row names and is checked against; null on a shape that has none.
     groups: shape?.groups && typeof shape.groups === "object" ? shape.groups : null,
     served: readServed(runDir),
+    // The applied-for marks, written by the job before any model ran: a ground on a floor's mark is refused on the
+    // client's own mark. A scope that names one mark as a string names it all the same.
+    marks: Array.isArray(scope?.marks) ? scope.marks : (typeof scope?.marks === "string" && scope.marks ? [scope.marks] : []),
   };
+  // What each record's goods rest on (goods-evidence.mjs), which a ground on a floor's goods is checked against. Read
+  // only when a ground needs it: the record runs to megabytes and the form is judged on every pass. null where the
+  // run wrote none, which establishes no goods.
+  let evidence;
+  Object.defineProperty(input, "evidence", { enumerable: false, get: () => (evidence === undefined ? (evidence = readGoodsStates(runDir)) : evidence) });
+  return input;
+}
+
+/** canonical uri → the state goods-evidence.mjs recorded for that record's goods; null with no record. */
+export function readGoodsStates(runDir) {
+  const doc = readJson(driverDir(runDir, "goods-evidence.json"));
+  if (!Array.isArray(doc?.records)) return null;
+  const out = new Map();
+  for (const r of doc.records) { const k = normalizeRecordUri(r?.uri); if (k && typeof r?.state === "string") out.set(k, r.state); }
+  return out;
 }
 
 /**

package/driver/placement-form.mjs

@@ -112,11 +112,15 @@ export const SELECT_ROW_CONTRACT = Object.freeze({
 // (ruled 2026-10-12). It is not a candidate, it renders into no placement, and nothing bounds how many there are.
 export const SET_ASIDE_ROW_FIELDS = ["set_aside", "ground", "on"];
 /**
- * What a ground setting a floor aside by name may be about (ruled 2026-10-12): its status or its territory.
- * Never its goods, which decide whether it sits in (a) or (b), and in a crowd (b)'s row is the goods ground;
- * never its owner's customers or field, whatever `on` says, so the form reads the ground's words too.
+ * What a ground setting a floor aside by name may be about: its status, its territory, its registered goods or a
+ * reasoned comparison of its mark with the client's (ruled 2026-10-27, superseding the status-or-territory rule of
+ * 2026-10-12). Never its owner's customers or field. The union checks each against the run's own evidence: a goods
+ * ground needs the line read and every floor's goods held complete, and a mark ground is refused on the client's
+ * own mark. The words of a ground on status or territory are read too, for customers, field and goods.
  */
-export const FLOOR_GROUND_ON = Object.freeze(["status", "territory"]);
+export const FLOOR_GROUND_ON = Object.freeze(["status", "territory", "goods", "mark"]);
+/** The grounds whose words the form reads for customers, field and goods: the two that are about neither. */
+export const FLOOR_GROUND_WORDS_READ = Object.freeze(["status", "territory"]);
 export const FLOOR_GROUND_REFUSED = /\b(?:customers?|consumers?|clients|clientele|users?|audiences?|buyers?|purchasers?|patients?|professionals?|channels?|markets?|marketplaces?|sectors?|fields?|industr(?:y|ies|ial)|business(?:es)?|activit(?:y|ies)|commerce|commercial|trad(?:e|es|ing)(?!\s*-?\s*marks?)|distribution|wholesale|retail(?:ers?)?|sells?|sold|selling|b2b|b2c|off[- ]field|goods|products?|services?(?!\s*-?\s*marks?)|merchandise)\b/i;
 /** The lists a group row may name: the shape's groups, the rest, and the lines the goods test could not place. */
 export const ROW_GROUPS = Object.freeze([...BAND_GROUPS, "no_goods"]);
@@ -124,24 +128,30 @@ export const SET_ASIDE_ROW_CONTRACT = Object.freeze({
   when: "a line the shape lists, one mark of one owner, whose records you do not carry. One row gives that "
     + "line its ground.",
   fields: SET_ASIDE_ROW_FIELDS,
-  set_aside: "one record id of that line, from the band. The driver finds the line on the register's own "
-    + "projection; the ground covers every record of that mark of that owner the form does not place, and "
-    + "never another mark of the owner, which needs its own fate. A record that names no owner stands for its "
-    + "own position only.",
+  set_aside: "One record id of the line, from the band, or a list of record ids, one per line, that share one ground. "
+    + "The ground covers every unplaced record of that mark of that owner. Another mark of the same owner needs its "
+    + "own fate. A record that names no owner stands for its own position only.",
   ground: "why this line's records are not carried, in a lawyer's words.",
-  on: "where the line holds a floor, a live identical or near-identical mark in an ordered class: what the "
-    + "ground is about, status or territory. A floor is never set aside on its goods, which decide its group, "
-    + "nor on its owner, its customers or its field; a ground in those terms is refused.",
+  on: "Required when the line holds a floor (a live identical or near-identical mark in an ordered class): one of "
+    + "status, territory, goods, mark. Use goods when the registered goods, read in full, do not meet the client's "
+    + "particular goods. Use mark when a reasoned comparison with the client's mark shows the two do not conflict. "
+    + "The owner, its customers and its field are never a ground.",
   not_a_candidate: "It places nothing. A record of the same line you do place stays placed.",
   latest: "A later row for the same line replaces the earlier ground. To remove one, hand back "
     + "{\"retract\":\"<its set_aside id>\"}.",
-  unresolved: "A `set_aside` the band does not hold, one with no ground, or a floor's row whose `on` is not "
-    + "status or territory or whose ground speaks of customers, channels, markets or field, is reported back "
-    + "to you by id.",
+  unresolved: "The driver says a row back by id when: its record is not in the band; it has no ground; a floor's "
+    + "`on` is missing or not one of the four; a status or territory ground speaks of goods, customers, channels, "
+    + "markets or field; a goods ground rests on a line not read, or on goods the run does not hold in full; a mark "
+    + "ground names the client's own mark, or the run holds no applied-for mark to compare with. In a list, each "
+    + "line is judged on its own.",
 });
 
+/** The record ids a set-aside row names: one, or the list of lines one ground covers. PURE. */
+export const setAsideMembers = (row) => (Array.isArray(row?.set_aside) ? row.set_aside : [row?.set_aside])
+  .filter((id) => typeof id === "string" && id.trim() !== "").map((id) => id.trim());
+
 /** Is this submitted row an owner's set-aside? PURE. */
-export const isSetAsideRow = (row) => typeof row?.set_aside === "string" && row.set_aside.trim() !== "";
+export const isSetAsideRow = (row) => setAsideMembers(row).length > 0;
 
 // ONE ROW PER GROUP. The band shape lists the band in the lawyer's order, one line per mark of an owner,
 // the rest last. A listed line gets a fate, not a row: it is placed, or set aside by name, or covered

package/driver/placement-union.mjs

@@ -27,9 +27,11 @@ import { buildSelectionIndex, selectionOf, rowIsSettled, seatFields, formRowKey,
   SEAT_ROW_CONTRACT, SELECT_ROW_CONTRACT, PLACEMENT_FORM_PROVENANCE,
   SET_ASIDE_ROW_CONTRACT, isSetAsideRow,
   SET_ASIDE_GROUP_CONTRACT, isSetAsideGroupRow, groupName, groupOfKeys, namedKey, lineKey, servedLines,
-  groupRowCoversFloors, groupRowCoversFloorLine, FLOOR_GROUND_ON, FLOOR_GROUND_REFUSED, ROW_GROUPS, renderPlacementsJson, setAsideGrounds } from "./placement-form.mjs";
+  groupRowCoversFloors, groupRowCoversFloorLine, FLOOR_GROUND_ON, FLOOR_GROUND_WORDS_READ, FLOOR_GROUND_REFUSED, ROW_GROUPS, renderPlacementsJson,
+  setAsideGrounds, setAsideMembers } from "./placement-form.mjs";
 import { groupPageCall } from "./band-shape.mjs";
 import { normalizeRecordUri } from "./registry-fidelity.mjs";
+import { formKey } from "../providers/_shared/script-form.mjs";   // — the one fold for "is this the same form of the mark"
 import { reconcileFloorDuty } from "./floor-duty.mjs";
 
 /** Why a `select` the fold does not hold is refused, said back with it. */
@@ -162,8 +164,8 @@ export function unionPlacementForm(prior, submitted, input, { covered = false }
   // placements.json. Prior first, so a later row for the same owner replaces the earlier ground, and a
   // retraction names the record id the row set aside. A row the band cannot resolve, or one with no
   // ground, is reported back by id, never dropped in silence.
-  // A ground by name covers the named line only. On a line holding a floor it is about the mark, its goods,
-  // its status or its territory, and says which in `on`; a ground about the owner never sets a floor aside.
+  // A ground by name covers the named line only. On a line holding a floor it is about its status, its territory,
+  // its registered goods or its mark, and says which in `on`; a ground about the owner never sets a floor aside.
   const groups = input?.groups ?? null;
   const floorUris = new Set((Array.isArray(input?.floors) ? input.floors : []).map((f) => normalizeRecordUri(f?.record_id) || String(f?.record_id ?? "")).filter(Boolean));
   const holdsFloor = (canonical) => (canonical?.records ?? []).some((u) => floorUris.has(normalizeRecordUri(u) || String(u ?? "")));
@@ -174,10 +176,52 @@ export function unionPlacementForm(prior, submitted, input, { covered = false }
     ...["a", "b", "c", "d", "no_goods"].flatMap((g) => (Array.isArray(groups?.[g]?.list) ? groups[g].list : []).filter((l) => l?.floors > 0).map((l) => l.key)),
   ]);
   const lineHoldsFloor = (canonical) => holdsFloor(canonical) || floorLines.has(namedKey(canonical));
+  // THE FLOORS OF EACH LINE, which a ground on a floor's goods or mark is checked against record by record.
+  const floorsOfLine = new Map();
+  for (const f of (Array.isArray(input?.floors) ? input.floors : [])) {
+    const u = normalizeRecordUri(f?.record_id) || String(f?.record_id ?? "");
+    const k = u ? namedKey(index.resolve(u)) : null;
+    if (k) floorsOfLine.set(k, [...(floorsOfLine.get(k) ?? []), { uri: u, mark: f?.mark_text ?? null }]);
+  }
+  // The records a ground on a line's goods or mark must hold for: the line's floors and the records of the position
+  // the row names, so a line the projection keys apart from its floors is still checked on the records it names.
+  const checkedRecords = (canonical) => {
+    const byUri = new Map((floorsOfLine.get(namedKey(canonical)) ?? []).map((f) => [f.uri, f]));
+    for (const u of canonical?.records ?? []) { const k = normalizeRecordUri(u) || String(u ?? ""); if (k && !byUri.has(k)) byUri.set(k, { uri: k, mark: canonical?.mark ?? null }); }
+    return [...byUri.values()];
+  };
+  const servedSet = servedLines(groups, input?.served, index);
+  const clientMarks = new Set((Array.isArray(input?.marks) ? input.marks : []).map((m) => formKey(String(m ?? ""))).filter(Boolean));
+  // WHY A GROUND ON A FLOOR'S GOODS OR MARK DOES NOT HOLD, or "" where it does (ruled 2026-10-27). Identical spelling
+  // and a shared class no longer bar the judgment; what bars it is the evidence. A goods ground stands on a line the
+  // step read and on goods the run holds complete for every floor of it: cut, unknown or missing goods establish
+  // nothing. A mark ground is a comparison with the client's mark, so it cannot set aside the client's mark itself.
+  const evidenceProblem = (on, canonical) => {
+    const records = checkedRecords(canonical);
+    if (on === "goods") {
+      if (!servedSet.has(namedKey(canonical)))
+        return "this line has not been read. Read it in band_shape or its group's page, or open its record with band_record, before you set it aside on its goods";
+      const states = input?.evidence instanceof Map ? input.evidence : null;
+      if (!states) return "the run has no record of this line's goods, so a goods ground cannot be checked. Place the line, or set it aside on its status, territory or mark";
+      const short = records.filter((r) => states.get(r.uri) !== "complete");
+      if (short.length)
+        return `the run does not hold the goods of ${short.slice(0, 3).map((r) => `${r.uri} (${states.get(r.uri) ?? "not recorded"})`).join(", ")}${short.length > 3 ? `, and ${short.length - 3} more` : ""} in full, so a goods ground cannot stand. Place the line, or set it aside on its status, territory or mark`;
+    }
+    if (on === "mark") {
+      if (!clientMarks.size) return "the run has no applied-for mark to compare with. Place the line, or set it aside on its status, territory or goods";
+      const own = records.find((r) => clientMarks.has(formKey(String(r.mark ?? ""))));
+      if (own) return `${own.uri} carries the client's own mark, so a mark ground cannot set it aside. Place the line, or set it aside on its status, territory or goods`;
+    }
+    return "";
+  };
   const setAside = new Map();
   const setAsideRefused = [];
   const takeSetAside = (row) => {
-    const id = String(row.set_aside).trim();
+    // A LIST UNDER ONE GROUND is taken line by line: each member stands or is reported back on its own evidence, so a
+    // shared ground covers only the lines it holds for, and the exceptions are said back by id.
+    const members = setAsideMembers(row);
+    if (members.length > 1) { for (const m of members) takeSetAside({ ...row, set_aside: m }); return; }
+    const id = members[0];
     const ground = typeof row.ground === "string" ? row.ground.trim() : "";
     const canonical = index.resolve(id);
     const refuse = (why) => { if (!setAsideRefused.some((x) => x.set_aside === id && x.why === why)) setAsideRefused.push({ set_aside: id, why }); };
@@ -185,8 +229,10 @@ export function unionPlacementForm(prior, submitted, input, { covered = false }
     if (!ground) { refuse("no ground"); return; }
     const on = typeof row.on === "string" ? row.on.trim().toLowerCase() : "";
     if (lineHoldsFloor(canonical)) {
-      if (!FLOOR_GROUND_ON.includes(on)) { refuse(`a floor is set aside by name only on its status or its territory: give "on" as one of ${FLOOR_GROUND_ON.join(", ")}`); return; }
-      if (FLOOR_GROUND_REFUSED.test(ground)) { refuse("a floor is never set aside on its owner's customers, channels, markets or field: write a ground about its status or its territory"); return; }
+      if (!FLOOR_GROUND_ON.includes(on)) { refuse(`a floor's set-aside needs "on": one of ${FLOOR_GROUND_ON.join(", ")}`); return; }
+      if (FLOOR_GROUND_WORDS_READ.includes(on) && FLOOR_GROUND_REFUSED.test(ground)) { refuse(`a ${on} ground is about the ${on} only, and this one speaks of goods, customers, channels, markets or field. Rewrite it about the ${on}, or send a ground about the registered goods with "on": "goods"`); return; }
+      const problem = evidenceProblem(on, canonical);
+      if (problem) { refuse(problem); return; }
     }
     const key = namedKey(canonical);
     setAside.delete(key);
@@ -217,7 +263,6 @@ export function unionPlacementForm(prior, submitted, input, { covered = false }
   // does not list, a count that is not the shape's, or a row with no ground is reported back, never dropped.
   const setAsideGroups = new Map();
   const groupRefused = [];
-  const servedSet = servedLines(groups, input?.served, index);
   const takeGroup = (row) => {
     const written = String(row.set_aside_group).trim();
     const refuse = (why) => { if (!groupRefused.some((x) => x.set_aside_group === written && x.why === why)) groupRefused.push({ set_aside_group: written, why }); };
@@ -289,7 +334,7 @@ export function unionPlacementForm(prior, submitted, input, { covered = false }
     // AN IDENTICAL MARK LIVE IN AN ORDERED OR FRAME-ADDED CLASS IS NEVER OUT-OF-SCOPE-FILTERED. The tier is
     // refused, said back, and the row left open, so the floor duty still owes it a fate.
     if (row.tier === "out-of-scope-filtered" && holdsFloor(row)) {
-      tierRefused.push({ select: row.select ?? null, why: "an identical mark live in an ordered or frame-added class is never out-of-scope-filtered: place it, sheet-2 at the least, or set it aside by name on its status or its territory" });
+      tierRefused.push({ select: row.select ?? null, why: "a floor never takes out-of-scope-filtered. Place it at headline-candidate or sheet-2, or set its line aside by name" });
       row.tier = null;
     }
     // JUDGED ON THE MERGED ROW, not on either input — a tier written on one pass and its reason on the

package/driver/publish/index.mjs

@@ -1823,15 +1823,19 @@ export function composeEmailHtml(reportMdPath, url, auditFile, names = [], deliv
   // doc-52 — the cover banner speaks the SAME plain "Only you can close these" wording as the report, never
   // the engine clamp reasons (opts.conditions = verdict.json reasons). Machinery-only clamps (no client
   // item authored) degrade to one generic plain line — never raw engine jargon, never truncated mid-sentence.
-  const emailConditions = opts?.verdict === 'CONDITIONAL' ? actYouConditions(parseActionBuckets(secs['Actions']).you) : [];
+  // A BLOCKING RESULT KEEPS THE REPORT'S ITEMS TOO (ruled 2026-10-27). The box showed only on a CONDITIONAL result, so
+  // a blocking one lost the client's own actions the report lists. It shows them under the report's heading in the
+  // report's words, and only where the report names any: no empty box, no fallback line.
+  const emailConditions = opts?.verdict === 'CONDITIONAL' || opts?.verdict === 'BLOCKING' ? actYouConditions(parseActionBuckets(secs['Actions']).you) : [];
   // THE REPORT IS THE MASTER (ruled 2026-09-22). The banner used to print a second summary composed
   // beside the report — "On hold — …" on a run the report called conditional, although nothing is ever
   // held — and before that the delivery gate's word. It now quotes the report: the rating, then the
   // report's own conclusion (below), and where the report names what only the client can close, those
   // items under the report's own heading. Nothing here composes a sentence of its own.
+  const closeBox = (items) => `<p style="margin:0 0 8px;padding:8px 10px;background:#fdeeee;border:1px solid #c98a86;color:#6e1512"><b>Only you can close these</b><br>${items.map((r) => `• ${cell(String(r))}`).join('<br>')}</p>`;
   const verdictBound = opts?.verdict === 'CONDITIONAL'
-    ? `<p style="margin:0 0 8px;padding:8px 10px;background:#fdeeee;border:1px solid #c98a86;color:#6e1512"><b>Only you can close these</b><br>${(emailConditions.length ? emailConditions : ['the open items set out in the report, before relying on a clean result']).map((r) => `• ${cell(String(r))}`).join('<br>')}</p>`
-    : '';
+    ? closeBox(emailConditions.length ? emailConditions : ['the open items set out in the report, before relying on a clean result'])
+    : opts?.verdict === 'BLOCKING' && emailConditions.length ? closeBox(emailConditions) : '';
 
   const reviewHeadline = `<div style="${FONT};font-size:11pt;color:#1a1a2e;margin:0 0 14px">`
     + flagBanner

package/driver/runner.mjs

@@ -43,7 +43,7 @@ import { checkResolvedProduct } from "./scope-rules.mjs";   // every resolved-pr
 import { freeSlots } from "./slot-lock.mjs";   // admission arithmetic — see drainQueue
 import { orderedQueueFiles } from "./queue-order.mjs";   // the order jobs are admitted in (shared with the portal)
 import { isCancelled } from "./cancel.mjs";   // a stopped run must not come back through any resume path
-import { AGENT_WHATSAPP } from "./stages.mjs";
+import { whatsappRouting } from "./stages.mjs";
 import { writeOutboxPacket } from "./outbox.mjs";
 import { writeRunStatus, terminalRunState } from "./progress.mjs";   // A5 — grace-exit park + reclaim-bound terminal go through the guarded status writer; terminalRunState is the run record's own terminal vocabulary (2155)
 import { identitySeed } from "./progress.mjs";   // — the same stamp a run seeds, for the process that runs them
@@ -702,7 +702,7 @@ function preRunFailNotify(agentId, base, job, reason) {
     jobId: job?.id ?? null, msgId: job?.msgId ?? null,
     forwarder: job?.forwarder ?? null, forwarderEmail: job?.forwarderEmail ?? null,
     markName: (job?.markName ?? job?.name ?? job?.marks?.[0]?.name) || null,
-    whatsappTo: AGENT_WHATSAPP[agentId] ?? null,
+    ...whatsappRouting(job, agentId),   // to whoever asked, as every other notice (the-notice-goes-to-whoever-asked)
     reason: terminalReasonFields(reason).reason, text,
   });
   note(`[runner] pre-run failure ${p ? `packet \u2192 ${p}` : "packet write FAILED"} for ${base}`);
@@ -739,7 +739,7 @@ async function backstopFailureNotice({ res, job, agentId, base, codename, studio
       // canonical runId form (charter P1 §3): `<slug>-<date>-<codename>` — owned.dir's leaf IS
       // "<date>-<codename>", so the dated id is derivable even here (matches status.runId + rescan).
       runId: `${slug}-${basename(owned.dir)}`, agent: agentId, job, failedStage: "pre-run",
-      shortReason, reasonVerbatim: reason.slice(0, 1000), whatsappTo: AGENT_WHATSAPP[agentId] ?? null,
+      shortReason, reasonVerbatim: reason.slice(0, 1000),
     });
     // same per-send invariant as the pipeline's failure path: a fresh notice supersedes an older .sent
     // and its per-channel receipts (B4 — stale receipts would make clearotron-deliver skip this notice)
@@ -2089,7 +2089,7 @@ function reclaimOrphanedClaims(qdir, agentId) {
               // comment above calls out for NAMING THE ARTIFACT DIRECTORY at its end: the status field
               // was repaired by and the notice a human actually reads was left cutting it blind.
               shortReason: rt.reason, reasonVerbatim: reasonText, terminalKind: "reclaim-exhausted",
-              priorAttempts: priorReclaims, whatsappTo: AGENT_WHATSAPP[agentId] ?? null,
+              priorAttempts: priorReclaims,
             });
             try { rmSync(join(owned.dir, ".sent"), { force: true }); } catch { /* none */ }
             try { rmSync(driverDir(owned.dir, "send-receipts.json"), { force: true }); } catch { /* none */ }

package/driver/skills/clearance-register/digest.md

@@ -396,7 +396,7 @@ Every judgment below spans the band and/or needs data a single unit cannot have,
 **Consume `placement-recommendations.md` (from Touchpoint 2 `placement-inquiry`).** The per-candidate tiers ALSO arrive structured in `placements.json` beside the md — `{mark, owner, jurisdiction, records[], tier, reason}` per candidate (plus an optional `borderline: true` — see below), `reason` carrying placement's stated reasoning. When present, the JSON is the authoritative tier record: adopt or override each tier BY ENGAGING ITS `reason` (an override quotes the reason it contradicts — never a silent re-tier; a kept tier may tighten a label while reusing the reason). The md remains the home of the rulings tail (Disagreements, Coverage rulings, Open questions), which you carry forward exactly as below. On a corrective/repair pass do NOT re-read the whole md — the tiers are in the JSON, and the driver hands you the md's rulings tail verbatim in the dispatch (a `PLACEMENT RULINGS TAIL` block): adjudicate against it there, adopting or counter-reasoning each ruling. For each candidate `placement-inquiry` placed:
 - Find the matching entry in `placements.json` (mark text + owner + jurisdiction match; fall back to the md's tier sections on runs that predate the JSON)
 - Adopt the graduated outcome (`headline-candidate` / `sheet-2` / `watchlist-annex` / `out-of-scope-filtered`) as the placement
-- A sheet-2 placement is adopted as it stands — the driver writes its Sheet-2 row with placement's reason — unless you override it; you send rows for the headline positions and for the placements you override.
+- Keep each placement decision that its evidence supports, with its reason. Before an entry goes to the writer, decide its relevance from the evidence you hold. Carry plausible conflicts and the questions the evidence leaves open. Drop every other entry once, with a substantive reason. The length of the report, thin use, a small owner and possible revocation are never substantive reasons. On its own, a sheet-2 tier, a class match or the words “completes the record” is no reason to carry an entry. Change a placement decision only by naming the evidence or the error that changes it.
 - **Between `headline-candidate` and `sheet-2`, what you are adopting is an ANSWER, not a label.** Those two tiers are placement-inquiry's written answer to one question — *does this conflict change the advice, or only complete the record?* (a headline entry names what it changes; a sheet-2 entry states why the advice reads the same either way). Adopting means adopting that answer. **Overriding means answering the SAME question the other way, in writing**, in your `### Disagreement resolutions` row — never re-labelling the tier and never substituting a risk-tier argument for the question. An override that does not say what the conflict does (or does not do) to the advice has not engaged the placement
 - **A `"borderline": true` entry in `placements.json` is placement declaring that its own answer could be argued either way on this record.** That is the expected place for your judgment to differ, and it is a correct declaration rather than a defect — but it must be **resolved either way, explicitly**, in a `### Disagreement resolutions` row (`ADOPTED placement-inquiry — <the reading you took, and why>` / `OVERRODE — <the other reading, and why>`), never silently carried and never left as a shrug. **The declaration is internal adjudication only**: it belongs in your audit trail beside the other open verification flags, and no borderline mark, no "arguably", no "either way" derived from it goes into the findings prose the client reads — you resolve it here so the report does not have to hedge it there
 - The "Disagreements / flags surfaced to downstream" section names cases where placement-inquiry deviated from class-match — read those reasonings carefully

package/driver/skills/clearance-search/phase2-execution.md

@@ -155,9 +155,9 @@ is not a reason to skip it, and "the rule said so" is not an answer.
   headline.)
 - **Dominant-element spine / calibration:** is each finding ranked by the *dominant element* + whole-mark confusion
   test? Is a distinguished mark (house-mark-prefixed) **over-rated**, or a
-  bare-dominant-element-in-field conflict **under-rated or dropped**? Did any **on-point identical /
-  near-identical-in-class** hit fall out of the deliverable (it must not — even if revocable, and regardless
-  of filer size)? Is any escalation of a distinguished mark resting on optics/PR/partner rather than a
+  bare-dominant-element-in-field conflict **under-rated or dropped**? Did an **on-point identical or
+  near-identical mark in the class** fall out of the report? It must not, even if revocable and whatever its
+  owner's size. Is any escalation of a distinguished mark resting on optics/PR/partner rather than a
   named confusion theory? Is the headline risk driven by the top on-point conflicts, not a distinguished
   mark or unrelated-field noise?
 - **Coverage ledger:** is any `deferred` / `coverage-limited` row being narrated (or about to be narrated) as a

package/driver/skills/clearance-search/synthesis-rules.md

@@ -164,9 +164,9 @@ Before rating individual findings, **rank and select them by the consumer-confus
    same/related G&S. Bare-dominant-element-in-field = top; dominant-element-plus-distinctive-matter
    (a third-party house mark in front of the shared element) = lower; unrelated-G&S = excluded as a legal
    finding (commercial awareness only).
-2. **Never drop an on-point identical / near-identical mark in the relevant class** — a position placement put on
-   sheet 2 is written up where it changes the advice, and otherwise set aside with its ground — even if it looks
-   revocable or shelved. The staff lawyer: *"until it has actually been revoked it remains a live legal
+2. **Never drop an on-point identical or near-identical mark in the relevant class, even if it looks revocable or
+   shelved.** A position placement put on sheet 2 is written up when it changes the advice, and otherwise declined
+   with its ground. The staff lawyer: *"until it has actually been revoked it remains a live legal
    risk."* Surface it, rank it high, flag the non-use vulnerability as a Stage-2 mitigation. **Non-use is
    a revocation DEFENCE, never an injunction shield (spec-48 C5): a registered right can support an
    injunction without the owner's own use (country-dependent; grace periods run ~5 years). Never reason

package/driver/skills/placement-inquiry/SKILL.md

@@ -28,7 +28,7 @@ Inherits the orchestrator's tier when invoked inline. No `sessions_spawn` — th
 ## Inputs you receive
 
 - `matter-context.md` from `matter-frame` at `studio/clearance-search/<slug>/<date>/matter-context.md` (the strategic foundation — read it once, reference it throughout)
-- **The named band** — read through the **band tools** (every call lands in the run's reading audit; never slice band files with shell). `band_shape` first: the deterministic shape of the merged band — totals, mechanical similarity tiers, **THE FLOORS** (every live in-class identical/near-identical record, each marked on its line in the band — **every floor has a fate on the form: placed by record id, or set aside by name on its status or its territory (the row's `on`), never on its goods or its owner's customers or field; only a crowd's row of a thousand records or more in (b) covers a floor.** Discussing a floor in your prose is NOT accounting for it: the form is what the driver can check, and a floor with no fate on it is recorded as unanswered whatever the prose says. This is the one duty with no cap — see **Length target**, which bounds the general band and not this), census, owner concentrations, crowd descriptors, blind spots. A large shape is served in parts, each naming the next call. Then `band_lookup` / `band_record` for the records your inquiry needs. This is the funnel's real output, lifted across the firewall:
+- **The named band** — read through the **band tools** (every call lands in the run's reading audit; never slice band files with shell). `band_shape` first: the deterministic shape of the merged band — totals, mechanical similarity tiers, **THE FLOORS** (every live in-class identical/near-identical record, each marked on its line in the band — **every floor gets a fate on the form: placed by record id, or set aside by name with `on` set to status, territory, goods or mark; only a crowd's row of a thousand records or more in (b) covers a floor.** Discussing a floor in your prose is NOT accounting for it: the form is what the driver can check, and a floor with no fate on it is recorded as unanswered whatever the prose says. This is the one duty with no cap — see **Length target**, which bounds the general band and not this), census, owner concentrations, crowd descriptors, blind spots. A large shape is served in parts, each naming the next call. Then `band_lookup` / `band_record` for the records your inquiry needs. This is the funnel's real output, lifted across the firewall:
   - **enumerated records** — every named record the funnel paged to completion, each carrying `record_id, mark_text, classes, status, owner_name, owner_country, application_date, registration_date, expiry_date, jurisdictions, screen_verdict` (+ `_query` provenance). Nothing was pre-sampled, so your gate is the *only* gate. Fifty? Read them all. A few hundred? Sort by the client's goods and markets, read the near ones first, list the rest. A thousand or more? The field is crowded: read the identical and live ones for the client's goods, tell the client it is crowded, and do not write up the rest. Count each group the shape lists on its own, and apply this to each by its own count. Where the shape shows (a) by its first page, page every line of it with `band_lookup`'s `group` filter before its row: reading a line is not writing it up. A crowd of a thousand or more outside (a) stands on its first page read and the count. The shape lists the band in this order: (a) identical or near-identical to the mark or one of its forms, for the client's goods; (b) the same, in the ordered classes; (c) the same family as the mark, for the client's goods; (d) every other live mark in the ordered classes, for the client's goods; then the rest. The ordered classes are the instructed ones and any class the frame added. Inside each group the lines run first by the client's goods on a live record in the ordered classes, then by live records in those classes, then by goods words, then by the client's markets. In a group of a few hundred, every line is read: the near ones get the full inquiry and a row; every other line is either carried or left to the group's row with the reason, except a floor, which is placed or set aside by name.
   - **`incomplete` crowd descriptors** — a query the funnel could NOT enumerate (genuinely too large, provider cap, budget): `query, total_hits, fetched, reason`. These are NOT findings and NOT clean negatives — they are signals you must rule on (cleared / material-gap; see "Crowd-descriptor materiality" below). They ride along on matching lookups too, so a counted-only zone can never read as a clean.
   - The unit's compact prose digest (`register-units/<axis>.md`) still exists for the audit trail. **The band shape, the band's summary, is the material you judge from; open a record only where the judgment needs it.** Before you set a line aside by name on its goods, read its goods in `band_record`, unless its goods words already show the ground on goods established as complete. Missing words in cut goods, or in goods whose completeness is unknown, do not establish that the goods are unrelated.
@@ -80,7 +80,7 @@ Two things the question deliberately is **not**. It is not "does this warrant th
 
 Judge an owner's records as a set. Write the position from the record in the client's market and class, quoting its goods. Carry forward only what a lawyer would raise with the client. Write down what you set aside and why.
 
-In the placement form each line the shape lists, one mark of one owner, gets a fate, not a row: you place it; or you set it aside by name, in one row naming one of its records (the form's `set_aside_row_contract`); or its group's one row covers it, saying why everything in that group you read and neither placed nor named is not raised with the client (the form's `set_aside_group_contract`). The rest is one such group. A group's row is refused until every line of the group was read, in the shape or by a lookup, except in a crowd of a thousand records or more outside (a), where it stands on the first page and the count; it covers a floor only in such a crowd in (b), and only once you have read the floor's line. A ground by name covers the named line only, never another mark of its owner, and on a floor it is about the mark's status or its territory, never its goods or its owner's customers or field. Neither kind is a candidate, and the length target below does not count them.
+In the placement form each line the shape lists, one mark of one owner, gets a fate, not a row: you place it; or you set it aside by name, in one row naming one of its records (the form's `set_aside_row_contract`); or its group's one row covers it, saying why everything in that group you read and neither placed nor named is not raised with the client (the form's `set_aside_group_contract`). The rest is one such group. A group's row is refused until every line of the group was read, in the shape or by a lookup, except in a crowd of a thousand records or more outside (a), where it stands on the first page and the count; it covers a floor only in such a crowd in (b), and only once you have read the floor's line. A set-aside by name covers the line it names and no other mark of that owner. A floor's line may be set aside on one of four grounds: its status, its territory, its registered goods, or a reasoned comparison of its mark with the client's mark. Read the evidence for the ground before you set the line aside. A missing product word is not evidence. One ground may name a list of lines: name only the lines its evidence supports, and give every other line its own fate. Neither kind is a candidate, and the length target below does not count them.
 
 ### Headline candidates
 
@@ -169,7 +169,7 @@ The inquiry above is primary. The patterns below describe how the inquiry's answ
 
 - Class match + customer-base overlap + active owner + live registration → typically **headline-candidate**
 - Class match + customer-base overlap + non-use vulnerable or distinguishing prefix → typically **headline-candidate** with Stage-2 mitigant flagged
-- Class match + no customer overlap + matter-context off-field flag → typically **out-of-scope-filtered**. An identical mark live in an ordered or added class is placed, sheet 2 at the least, unless it is set aside by name on its status or territory, or sits in a crowd of a thousand or more identical marks and its goods, read on its line, are not the client's goods, where the crowd's row stands for it; it is never out-of-scope-filtered.
+- Class match + no customer overlap + matter-context off-field flag → typically **out-of-scope-filtered**. A floor is a live identical or mechanically near-identical mark in an ordered or added class. Compare each floor's mark with the client's mark, and its registered goods with the client's particular goods. Place the floor when a conflict is plausible or the evidence leaves the question open. Otherwise set it aside, with the reason and the evidence. A shared class, or a match to a searched variant, is not on its own a reason to place a floor. Missing or incomplete goods, thin use, a small owner and possible revocation are never reasons to set a floor aside. A floor never takes out-of-scope-filtered.
 - Class match + no customer overlap + pending registration OR active enforcer history → typically **watchlist-annex**
 - Class match + partial customer overlap → typically **sheet-2**
 - Phonetic / visual variant + class match + on-field → **headline-candidate** or **sheet-2** as the promotion question answers it (does the variant change the advice, or only complete the record?), never on phonetic distance as such — **and** an *active same-field brand in the core classes* is not down-placed below the headline tier on phonetic distance alone (see Reasoning posture → "Active same-field brand"); phonetic distance is a rating-step input, not a placement demotion for a live in-class competitor

package/driver/stages.mjs

@@ -2463,7 +2463,7 @@ export const STAGES = {
       `PLACEMENT FORM (MANDATORY): record every placement in ${P.placementForm} — {"rows":[…]}, and DO NOT WRITE placements.json (the driver renders it from this form).`,
       `· A REGISTER candidate: {"select":"<one record URI it holds>","tier":"…","reason":"…"} (+ optional "borderline":true). Naming ONE record selects the whole position — a mark registered in several territories is one candidate and you tier it once. The driver fills mark, owner, records, territories and classes from the register record itself; anything you write in those fields on a selected row is ignored, so do not re-type them.`,
       `· A COMMON-LAW candidate the register does not hold: write the row in full — {"kind":"seat","mark","owner","jurisdiction","records":[],"tier","reason"}. An empty records list is correct there, never a gap.`,
-      `· EACH LINE THE SHAPE LISTS, one mark of one owner, gets a fate, not a row: place it; or set it aside by name, in a row naming one of its records with the fields the form's set_aside_row_contract gives, which covers that line's records the form does not place and never another mark of its owner (a record that names no owner stands for its own position), and sets a floor aside only on its status or its territory, said in "on", never on its goods or its owner's customers or field; or leave it to its group's row.\n· ONE ROW PER GROUP: for each of (a) to (d), and for the rest, one row with the fields the form's set_aside_group_contract gives sets aside every line in it you read and neither place nor name, with the group's count and your reason. Below a thousand records, and in (a) at any size, a row waits until you have read every line, paging (a) with band_lookup's group filter where the shape shows its first page; a crowd of a thousand or more outside (a) stands on its first page read and the count, and the lines the goods test could not place take such a row only in a crowd. A floor is placed, sheet-2 at the least, or set aside by name on its status or its territory; only a crowd's row in (b) may leave it to the row. Carry forward only what a lawyer would raise with the client. Write down what you set aside and why.`,
+      `· EACH LINE THE SHAPE LISTS (one mark of one owner) gets one fate: place it, set it aside by name, or leave it to its group's row. A set-aside by name is a row naming one of the line's records, with the fields in the form's set_aside_row_contract. It covers that line's unplaced records and no other mark of the owner. A record that names no owner stands for its own position. A floor's set-aside gives its ground in "on": status, territory, goods or mark.\n· ONE ROW PER GROUP: for each of (a) to (d), and for the rest, one row with the fields the form's set_aside_group_contract gives sets aside every line in it you read and neither place nor name, with the group's count and your reason. Below a thousand records, and in (a) at any size, a row waits until you have read every line, paging (a) with band_lookup's group filter where the shape shows its first page; a crowd of a thousand or more outside (a) stands on its first page read and the count, and the lines the goods test could not place take such a row only in a crowd. Place a floor at headline-candidate or sheet-2, or set it aside by name. Only a crowd's row in (b) may cover a floor. Carry forward only what a lawyer would raise with the client. Write down what you set aside and why.`,
       `· tier EXACTLY one of headline-candidate / sheet-2 / watchlist-annex / out-of-scope-filtered. reason = a SHORT PARAGRAPH carrying your STATED reasoning for the tier — the candidate characterisation (what the owner actually does, the customer/channel overlap read), the decisive placement ground, and any Stage-2 mitigant flag — substantial enough that a downstream stage can quote it and argue with it; NEVER a bare label, NEVER the full 7-point inquiry trace.`,
       `· The form ACCUMULATES across attempts: a row you complete stays complete even if a later pass never mentions it, so a pass that only fixes two rows writes only those two. To remove a row, hand back {"retract":"<its row_id>"} — silence never removes anything.`,
       `· The rulings tail of the md (Band reconciliation, Disagreements / flags surfaced to downstream, Coverage rulings & open questions, Open questions for the client / reviewer) is NOT mirrored into the form — it travels verbatim as prose.`,
@@ -2628,7 +2628,7 @@ export const STAGES = {
       // handed to it AS DATA by the driver (runDigest appends the PLACEMENT RULINGS TAIL block), never
       // left to the model to remember or to fetch back.
       `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.`,
-      `A sheet-2 placement is adopted as it stands — the driver writes its Sheet-2 row with placement's reason — unless you override it; you send rows for the headline positions and for the placements you override.`,
+      `Keep each placement decision that its evidence supports, with its reason. Before an entry goes to the writer, decide its relevance from the evidence you hold. Carry plausible conflicts and the questions the evidence leaves open. Drop every other entry once, with a substantive reason. The length of the report, thin use, a small owner and possible revocation are never substantive reasons. On its own, a sheet-2 tier, a class match or the words “completes the record” is no reason to carry an entry. Change a placement decision only by naming the evidence or the error that changes it. Send no row for a sheet-2 placement you keep: the driver writes it with placement's reason. Send a row for each headline position and for each placement you change.`,
       // 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.
       placementSetAsideBlock(placementSetAsides),
@@ -3326,11 +3326,11 @@ export const STAGES = {
       // grant carried and no dictation mentioned — "granted-but-never-ordered", which is the silent
       // capability hole in the other direction, and the one that shipped before. A seat that is never
       // told a tool exists does not use it, and nothing records that it did not.
-      `DECLINATIONS: what you do not deliver, you decline BY NAME through the \`record_declination\` tool. A position or page on your findings surface leaves this stage as a finding in ${P.findings} naming any of its records, or as one declination with its ground, and there is no third way out.`,
+      `DECLINATIONS: what you do not deliver, you decline BY NAME through the \`record_declination\` tool. End each position and page on your list with a finding, or with a declination whose reason is a fact about that position or page. Exclusions made before your step are complete: keep their evidence and reasons, and do not write them again. Reopen one only when you can name the evidence against it or the error in its reasoning. Never write a finding whose only purpose is to account for a position.`,
       ...(Array.isArray(findingsSurface) && findingsSurface.length ? [
         `DECLINATIONS (MANDATORY): the register digest carried ${findingsSurface.filter((r) => r?.kind !== "page").length} position(s) onto your findings surface${findingsSurface.some((r) => r?.kind === "page") ? `, and the web notes marked ${findingsSurface.filter((r) => r?.kind === "page").length} page(s) as candidates or conflicts` : ""}. Each one leaves this stage by one of two routes and there is no third: it becomes a finding in ${P.findings}, or you decline it BY NAME with a reason and one ground for the position. A position you simply do not mention is reported as a defect of this run, named individually in its trace and shipped as an open doubt, so silence costs you more than a declination ever will.${findingsSurface.some((r) => r?.kind === "page") ? " A page you do not mention is counted as a defect of this run." : ""}`,
         `Decline by calling the \`record_declination\` tool. Its schema names the fields it takes and what each is for — read them there, not here. The one thing to know before you call: you cite a record or page by its POSITION in the list below — there is no field for a mark name, a uri or a page address, so anything you were not handed cannot be expressed at all. The reason vocabulary is closed: ${DECLINATION_REASON_TOKENS.join(" / ")}, each an omission synthesis-rules.md already authorises, and if your ground is none of them the rules do not let you omit the record or page. ONE OF THEM IS NOT AVAILABLE ON A LIVE RECORD IN AN INSTRUCTED CLASS: \`not-worth-the-line\` is a statement about the report's budget rather than about the mark, and a live registration inside one of the matter's own classes is never omitted for want of room — carry it, or decline it on something true of THAT MARK. The call is refused if you try, so it costs you a turn. The grounds you write are one or two lines in your OWN words on why THIS record or page does not earn a line — never machine-parsed, and what the reviewing lawyer reads. Send them in one batch where you can; a refused row never voids its neighbours, and the answer names what is still undecided so you can finish in this turn.`,
-        `A REFUSAL FROM THAT TOOL IS ABOUT BOOKKEEPING, NEVER ABOUT YOUR LEGAL JUDGMENT. There is exactly ONE case: declining a mark IDENTICAL to the applied-for mark, live, in one of the matter's own filed classes, on a discretionary ground — because synthesis-rules.md orders that an on-point identical mark in the relevant class is never dropped, "regardless of filer profile", so such a declination contradicts the instruction you are already following. Nothing else is refused. If that record really is the applicant's own, or already delivered under another record, say exactly that with own-right or duplicate-of-delivered and it is accepted. Whether goods are related, whether a name is off-field, whether a conflict is worth the line — those are your calls and the tool does not have an opinion about any of them.`,
+        `A REFUSAL FROM THAT TOOL IS ABOUT THE RECORD'S FACTS, NEVER YOUR LEGAL JUDGMENT. Besides the room refusal above, it refuses one case: a mark IDENTICAL to the applied-for mark, live in one of the matter's filed classes, declined on its field, for want of room, or on its sign. Decline such a mark as unrelated-goods when the run holds its goods in full and they do not meet the matter's goods; say how in the ground. Decline it as own-right or duplicate-of-delivered when that is true. Whether goods are related, and whether a name is off-field, is your call.`,
         `The records on your findings surface, by position:`,
         ...findingsSurface.flatMap((r, i) => r?.kind === "page" ? [] : [`  ${i}. ${r.mark ?? "(unnamed)"}${r.owner ? ` — ${r.owner}` : ""}${r.tier ? ` [${r.tier}]` : ""}${r.uri ? ` ${r.uri}` : ""}${r.goods_from ? ` — goods: ${r.goods_from}` : ""}`]), ...(findingsSurface.some((r) => r?.kind === "page") ? [`The pages the web notes marked as candidates or conflicts, continuing the same positions:`, ...findingsSurface.flatMap((r, i) => r?.kind === "page" ? [`  ${i}. ${r.url ?? r.page}`] : [])] : []),
       ] : []),
@@ -4815,7 +4815,7 @@ export const placementSetAsideBlock = (decisions) => (Array.isArray(decisions) &
 
 export const refutationStandingLines = ({ registerOnly = false, job = {}, floorDecisions = null } = {}) => [
   PLACEMENT_BORDERLINE_NOTE,
-  `REGISTER VERIFICATION TOOLS: you hold the read-only band tools — band_shape (the deterministic shape of the complete register band, including floors marked on their lines; crowded groups may show only their first page), band_lookup (pull any record the narrative relies on or omits) and band_record (the official registry record fetched this run). Check the narrative's register assertions against them. A floor row the narrative neither rates nor reasons away is a FLAGGED CORRECTION unless a validated placement decision already accounts for it under the placement rules. Those decisions are listed below with their grounds and the records they cover. Check those grounds against the evidence; flag an unsupported decision. They are read-only and logged; you hold no live register tools (by design, never an outage).`,
+  `REGISTER VERIFICATION TOOLS: you hold the read-only band tools — band_shape (the deterministic shape of the complete register band, including floors marked on their lines; crowded groups may show only their first page), band_lookup (pull any record the narrative relies on or omits) and band_record (the official registry record fetched this run). Check the narrative's register assertions against them. Each floor must be rated in the narrative, reasoned away in it, or accounted for by a decision listed below. A floor that is none of these is a FLAGGED CORRECTION. Check each listed decision's ground against the evidence. Flag a decision only when you can name the evidence against its ground or the error in its reasoning. They are read-only and logged; you hold no live register tools (by design, never an outage).`,
   // The validated decisions themselves, written by the driver from the placement form (pipeline.mjs
   // placementFloorDecisionLines); none stands where the list is empty.
   ...(Array.isArray(floorDecisions) && floorDecisions.length ? floorDecisions : ["(none)"]),