clearotron 0.3.2-beta.10 → 0.3.2-beta.12

package/driver/publish/index.mjs

@@ -239,25 +239,25 @@ function indexRows(runs, { reportFile, linkPrefix = '', showAudit = true, client
     // anchors are neutralised; the client column → aliased. Keyed by customerKey + runId so a demo run is
     // exempt and shows real.
     const ck = r.customerKey || '';
-    const runAttrs = `data-anon-href data-anon-key="${esc(ck)}" data-anon-run="${esc(r.runId)}"`;
+    const runAttrs = `data-anon-href data-anon-key="${attrValue(ck)}" data-anon-run="${attrValue(r.runId)}"`;
     const mark = anonMark(r.matter, { key: ck, run: r.runId });
-    const matterCell = `<a ${runAttrs} href="${linkPrefix}${esc(r.runId)}/${reportFile}">${mark}</a>`;
+    const matterCell = `<a ${runAttrs} href="${linkPrefix}${attrValue(r.runId)}/${reportFile}">${mark}</a>`;
     // Run cell: staff surfaces show date · HH:mm (Zurich, same-day issuedAt only) · codename; the
     // customer-facing per-customer index shows the date ONLY — codenames and timestamps are internal.
     const t = client ? '' : issuedTime(r);
     const runCell = client ? esc(r.date) : `${esc(r.date)}${t ? ` · ${esc(t)}` : ''} · <code>${esc(r.codename || '')}</code>`;
-    return `    <tr data-client="${esc(ck)}">
+    return `    <tr data-client="${attrValue(ck)}">
       <td>${matterCell}</td>
       <td>${anonMark(r.title, { key: ck, run: r.runId })}</td>
       <td>${anonClient(r.client, ck)}</td>
-      <td><span class="b b-${esc(r.badge)}">${esc(r.overall)}</span>${qcFailed ? ' <span class="hold" title="machine QC checks failed — see the audit workbook">⚠ QC</span>' : ''}${!client && !qcFailed && r.clientGate?.inputsAbsent?.length ? ` <span class="disc" title="${escAttr(`published without ${r.clientGate.inputsAbsent.join(', ')} — each declared optional, so the release stands; the report was built without it`)}">◦ built without an input</span>` : ''}${
+      <td><span class="b b-${attrValue(r.badge)}">${esc(r.overall)}</span>${qcFailed ? ' <span class="hold" title="machine QC checks failed — see the audit workbook">⚠ QC</span>' : ''}${!client && !qcFailed && r.clientGate?.inputsAbsent?.length ? ` <span class="disc" title="${escAttr(`published without ${r.clientGate.inputsAbsent.join(', ')} — each declared optional, so the release stands; the report was built without it`)}">◦ built without an input</span>` : ''}${
         // spec 64 — the stance clause of THE one risk statement beside the (labelled) band pill, so the
         // index can never show a bare severity word that reads as the whole answer. The tier word leads
         // the statement; the pill already shows it, so the cell carries the clause after the first " — ".
         // Legacy meta.json (no statement) renders this cell byte-identically.
         r.statement ? `<span class="stmt" title="${escAttr(r.statement)}">${esc(String(r.statement).split(' — ').slice(1).join(' — ') || r.statement)}</span>` : ''}</td>
       <td>${runCell}</td>${showAudit ? `
-      <td>${r.auditFile ? `<a ${runAttrs} href="${linkPrefix}${esc(r.runId)}/${esc(r.auditFile)}">audit.xlsx</a>` : '—'}</td>` : ''}
+      <td>${r.auditFile ? `<a ${runAttrs} href="${linkPrefix}${attrValue(r.runId)}/${attrValue(r.auditFile)}">audit.xlsx</a>` : '—'}</td>` : ''}
     </tr>`;
   }).join('\n');
 }
@@ -275,7 +275,7 @@ function clientFilterBar(clients) {
   if (!clients || clients.length < 2) return '';
   // data-anon="client" goes on the <option> itself (a span inside <option> is invalid) so the demo overlay
   // aliases the visible label in privacy mode; the value stays the raw customerKey that data-client matches.
-  const opts = clients.map(c => `<option value="${esc(c.key)}" data-anon="client" data-anon-key="${esc(c.key)}">${esc(c.label)}</option>`).join('');
+  const opts = clients.map(c => `<option value="${attrValue(c.key)}" data-anon="client" data-anon-key="${attrValue(c.key)}">${esc(c.label)}</option>`).join('');
   return `<div class="filterbar"><label class="flbl" for="clientFilter">Client</label>` +
     `<select id="clientFilter"><option value="">All clients</option>${opts}</select></div>`;
 }
@@ -377,7 +377,7 @@ ${rows}
 // sidecar without importing this renderer. Imported as well as re-exported — `export ... from` re-exports
 // without binding the name in this module's scope, and regenIndex below calls readArchivedSet directly.
 export { ARCHIVE_TAGS_FILE, readArchivedSet, updateArchived } from './archive-tags.mjs';
-import { readArchivedSet } from './archive-tags.mjs';
+import { readArchivedSet } from './archive-tags.mjs'; import { attrValue, hrefAttr } from './attr.mjs';   // a quoted attribute, and an href
 
 // Collapsible "Older / retired runs" fold for the STAFF index: a count in the summary (so viewers see how many
 // runs we've done) with the names hidden until expanded. Named distinctly from the "Clearance reports" tab so
@@ -1665,9 +1665,9 @@ export function composeEmailHtml(reportMdPath, url, auditFile, names = [], deliv
   // Heading-neutral match: accept the new "Reviewer's open questions" and the legacy "Open questions for the reviewer".
   const oq = (secs['Summary'] || '').match(/\*\*(?:Reviewer's open questions|Open questions for the reviewer)[\s\S]*?(?=\n\n[^*\d])/i);
   // The report link rides HIGH — right under the bottom line in the headline, not buried below the table.
-  const reportLink = url
-    ? `<p style="margin:0 0 10px"><a href="${esc(url)}" style="color:#1a4fd6;font-weight:bold;font-size:12pt;text-decoration:none">▶ Open the full report</a>`
-      + (auditUrl ? ` &nbsp;·&nbsp; <a href="${esc(auditUrl)}" style="color:#3b4fd6;text-decoration:none">Download audit (Excel)</a>` : '')
+  const reportLink = hrefAttr(url)
+    ? `<p style="margin:0 0 10px"><a href="${hrefAttr(url)}" style="color:#1a4fd6;font-weight:bold;font-size:12pt;text-decoration:none">▶ Open the full report</a>`
+      + (hrefAttr(auditUrl) ? ` &nbsp;·&nbsp; <a href="${hrefAttr(auditUrl)}" style="color:#3b4fd6;text-decoration:none">Download audit (Excel)</a>` : '')
       + `</p>`
     : '';
   // The search-scope signal leads the email. The 2026-06-12 "lint flags do not render on the email" rule

package/driver/publish/parse.mjs

@@ -99,7 +99,7 @@ export function stripInternal(s, { client = false } = {}) {
   const out = [];
   for (let line of lines) {
     // normalize wrapped markers ("**::p:: x**", "*::p:: x*") so the marker is match-stable
-    line = line.replace(/(\*{1,2})\s*::p::\s*([\s\S]*?)\1/g, '::p:: $2');
+    line = line.replace(/(\*{1,2})\s*::p::([\s\S]*?)\1/g, (_, _star, x) => `::p:: ${x.replace(/^\s+/, '')}`);   // no `\s*` before the capture: overlapping it with the lazy body backtracked quadratically on an unclosed marker
     if (!line.includes('::p::')) { out.push(line); continue; }
     if (client) {
       const head = line.slice(0, line.indexOf('::p::')).replace(/[\s*_]+$/, '').trim();

package/driver/publish/render-knockout.mjs

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

package/driver/publish/render.mjs

@@ -25,7 +25,7 @@ import { fileURLToPath } from 'node:url';
 // its own split, which is how the two rules diverged. It calls stripTelemetry now, so the renderer holds
 // no copy of the RULE either, only a call to it.
 import { parseReport, stripInternal, stripTelemetry } from './parse.mjs';
-import { clientConditions } from '../terminal-clamp.mjs';
+import { clientConditions } from '../terminal-clamp.mjs'; import { hrefAttr } from './attr.mjs';   // an href is attribute-safe and http(s), or not a link
 import { EXPORT_TOGGLE, exportPopover, EXPORT_MENU_JS } from './report-topbar.mjs';   // the export menu's shell and behaviour, shared with the knockout template   // the reader's clause per condition, shared with the cover note
 import { COMMON_LAW, normRegion, regionName, REGION_NAMES } from './regions.mjs';
 import { parseFindingsJson, bindRecommendation, sentenceCaseLead, CLIENT_TIER_BY_COMPOSITE, bandOf, compareBlockingPower, inDispositionMode, reasonedNegativeGroups } from '../findings-model.mjs';
@@ -995,7 +995,7 @@ const NAMES_CAP = 8;
 function clearedGroupsHtml(searchDepth, auditFile) {
   const reg = (searchDepth && searchDepth.cleared && searchDepth.cleared.register) || [];
   if (!reg.length) return '';
-  const link = (n) => auditFile ? `<div class="cmore"><a class="wb" href="${escAttr(auditFile)}">All ${n.toLocaleString('en-GB')} in the audit workbook</a></div>` : '';
+  const link = (n) => hrefAttr(auditFile, { relative: true }) ? `<div class="cmore"><a class="wb" href="${hrefAttr(auditFile, { relative: true })}">All ${n.toLocaleString('en-GB')} in the audit workbook</a></div>` : '';
   return CLEARED_GROUP_ORDER.map((g) => {
     const items = reg.filter((c) => c.group === g);
     if (!items.length) return '';
@@ -1229,8 +1229,8 @@ function whatWasSearchedSection(opts, coverage = [], findings = [], recordsByUri
     : '';
   // THE BOARDS END THE SECTION WITH THE WORKBOOK: every search and its result are in the audit workbook,
   // which is where a reader who wants the record goes.
-  const more = opts?.auditFile
-    ? `<div class="cmore"><a class="wb" href="${escAttr(opts.auditFile)}">Every search and result, in the audit workbook</a></div>` : '';
+  const more = hrefAttr(opts?.auditFile, { relative: true })
+    ? `<div class="cmore"><a class="wb" href="${hrefAttr(opts.auditFile, { relative: true })}">Every search and result, in the audit workbook</a></div>` : '';
   if (!rows.length && !openHtml && !prov) return '';
   return `<div class="sec" id="searched"><span class="num"></span><h2>What was searched</h2></div>
   <details class="searched"><summary><span class="gname">Counts for this search</span></summary><div class="gbody">${
@@ -1631,7 +1631,7 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   const regUri = (u, fb) => {
     const h = regHref(u);
     const label = esc(u || fb || 'registration');
-    if (h) return `<a href="${esc(h)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
+    if (hrefAttr(h)) return `<a href="${hrefAttr(h)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
     const note = RECORD_CITATION ? NO_LINK_NOTE[RECORD_CITATION] : null;
     return note ? `${label}<span class="reg-nolink">${note}</span>` : label;
   };
@@ -1744,7 +1744,7 @@ function fullDetail(f, card, recordsByUri = new Map()) {
     const stat = status ? ` <i class="evstat">Evidence: ${esc(status)}</i>` : '';
     const urls = (String(src).match(/https?:\/\/[^\s,|]+/g) || []).map(u => u.replace(/[).,;:]+$/, ''));
     if (!urls.length) return `<li><b>${label}</b> ${esc(src)}${stat}</li>`;
-    const links = urls.map(u => `<a href="${esc(u)}" target="_blank" rel="noopener noreferrer">${esc(u.replace(/^https?:\/\//, '').slice(0, 48))}</a>`).join(' · ');
+    const links = urls.map(u => (hrefAttr(u) ? `<a href="${hrefAttr(u)}" target="_blank" rel="noopener noreferrer">${esc(u.replace(/^https?:\/\//, '').slice(0, 48))}</a>` : esc(u))).join(' · ');
     const rest = String(src).replace(/https?:\/\/[^\s,|]+/g, ' ').replace(/[\s,|]+/g, ' ').trim().replace(/^[—–-]\s*/, '');
     return `<li><b>${label}</b> ${links}${rest ? ` — ${esc(rest)}` : ''}${stat}</li>`;
   };
@@ -1796,7 +1796,7 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   // such line. The SOURCE LINK stays: it is the only address a reader has for the record on this card
   // until the workbook row lands beside it, and dropping both would take a fact away rather than a
   // label. With no link there is nothing left to say, so the row does not render at all.
-  const prov = link ? `<div class="prov"><a href="${esc(link)}" target="_blank" rel="noopener noreferrer">${esc(link.replace(/^https?:\/\//, '').slice(0, 48))}</a></div>` : '';
+  const prov = hrefAttr(link) ? `<div class="prov"><a href="${hrefAttr(link)}" target="_blank" rel="noopener noreferrer">${esc(link.replace(/^https?:\/\//, '').slice(0, 48))}</a></div>` : '';
   // WP-receipts W4 — the code-owned senior-right line (Owner decision 2026-07-05: VERY SIMPLE CLEAR ENGLISH,
   // stated qualification, verdict untouched). Verified senior → nothing extra (the W2 receipt line on
   // the fetched leg is the proof). Unverified → the open item, plainly, where the finding lives.
@@ -2551,7 +2551,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   const riskLabel = VERDICT_INFO ? (VERDICT_INFO.tier || TIER_STOP_PILL[i]) : RISK_STOPS[i].toUpperCase();
 
   // Excel/audit download — lives inside the topbar Export popover (portal-report strips the link at serve time for non-staff).
-  const excelBtn2 = !opts.auditFile ? '' : `<a class="util" href="${esc(opts.auditFile)}" download>⬇ Download full audit (Excel)</a>`;
+  const excelBtn2 = !hrefAttr(opts.auditFile, { relative: true }) ? '' : `<a class="util" href="${hrefAttr(opts.auditFile, { relative: true })}" download>⬇ Download full audit (Excel)</a>`;
 
   const cardFor = f => matchCard(f, cards);
   const recordsByUri = opts.recordsByUri || new Map();   // Instance #6 — the run's _records/ set (publishReport loads it)
@@ -2854,7 +2854,7 @@ import { officeReasonSentences } from './office-record-links.mjs';
 function officeRecordCell(uri, regUri, note) {
   const l = RECORD_LINKS?.get(String(uri || '').toLowerCase());
   if (!l?.label) return regUri(uri);
-  if (l.href) return `<a href="${esc(l.href)}" target="_blank" rel="noopener noreferrer">${esc(l.label)}</a>`;
+  if (hrefAttr(l.href)) return `<a href="${hrefAttr(l.href)}" target="_blank" rel="noopener noreferrer">${esc(l.label)}</a>`;
   return note ? `${esc(l.label)}<span class="reg-nolink">${note}</span>` : esc(l.label);
 }
 

package/driver/publish/xlsx.mjs

@@ -706,7 +706,13 @@ export function validateAudit(wb, { findings = [], coverage = [], coverageJudgme
   for (const name of EXPECT) if (!sheets.includes(name)) v.push(`missing tab "${name}"`);
 
   // 3 — banned internal vocabulary anywhere a lawyer can see (tab name, header, or any cell).
-  const scan = (txt, where) => { if (txt != null && BANNED.test(String(txt))) v.push(`banned vocab "${String(txt).match(BANNED)[0]}" in ${where}`); };
+  // A LINK IS A CITATION, NOT VOCABULARY. The sources a finding cites are URLs a lawyer clicks, and `https`
+  // inside one matched the list, so every published example workbook printed an advisory about its own
+  // links. The address is taken out before the scan; "HTTP 404" written as prose is still found.
+  const scan = (txt, where) => {
+    const words = txt == null ? null : String(txt).replace(/\bhttps?:\/\/[^\s<>"')\]]+/gi, " ");
+    if (words != null && BANNED.test(words)) v.push(`banned vocab "${words.match(BANNED)[0]}" in ${where}`);
+  };
   for (const name of sheets) scan(name, `tab name "${name}"`);
   for (const ws of wb.worksheets) {
     ws.eachRow((row, rn) => row.eachCell(cell => {

package/driver/queue-watch-verdict.mjs

@@ -104,7 +104,7 @@ export function queueWatchVerdict({ queueDirs, watched, unitPath, unitError = nu
       message: `this deployment resolves NO queue directory at all, so nothing enqueued to it can ever be drained (${unitPath} watches ${w.length})` };
   }
 
-  const norm = (p) => String(p ?? "").replace(/\/+$/, "");
+  const norm = (p) => { const s = String(p ?? ""); let e = s.length; while (e > 0 && s.charCodeAt(e - 1) === 47) e--; return s.slice(0, e); };   // trailing slashes, in one pass: `/\/+$/` retried every run of slashes that was not at the end
   const watchedSet = new Set(w.map(norm));
   const unwatched = q.map(norm).filter((d) => !watchedSet.has(d));
   const where = `${q.length} queue dir(s) resolved; ${unitPath} watches ${w.length}`;

package/driver/register-availability.mjs

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

package/driver/register-plan.mjs

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

package/driver/result-noun-fields.mjs

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

package/driver/stages-knockout.mjs

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