npm - clearotron - Versions diffs - 0.2.0 → 0.2.2 - Mend

clearotron 0.2.0 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (629) hide show

package/driver/publish/knockout.mjs CHANGED Viewed

@@ -10,7 +10,7 @@
 import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { driverDir, ensureDriverDir } from '../../shared/driver-dir.mjs';   //
-import { riskTier, TONE_TIER, regenIndex, regenSurfaces, auditRouteFor, markReportRouteFor } from './index.mjs';
+import { riskTier, TONE_TIER, regenIndex, regenSurfaces, auditRouteFor, markReportRouteFor, reportRouteFor } from './index.mjs';
 import { runKnockoutLint, deliveryFlagLines } from '../predelivery-lint.mjs';
 import { note } from '../log.mjs';
 import { addSheet } from './xlsx.mjs';
@@ -68,9 +68,13 @@ export const knockoutStatement = (framework, marks) =>
 // 11pt, no <!DOCTYPE>, no <head>, no <meta charset> — and they rendered a Depth 2 report as a grey
 // spreadsheet with the register hit-counts the customer paid for buried in a table cell. The report now
 // renders through publish/render-knockout.mjs in the product's own design language, off the same shared
-// stylesheet and brand tokens as the clearance report. Internal working material (the purple staff notes,
-// the model's registerEstimate) is not stripped from the report — it is not IN the report; it lives in
-// the audit workbook, which is what an internal artifact is for.
+// stylesheet and brand tokens as the clearance report.
+//
+// THE REVIEWER'S NOTES ARE ON THE REPORT SINCE 2026-09-07 (owner ruling, tracker issue 274). This
+// paragraph used to end "internal working material (the purple staff notes, the model's registerEstimate)
+// is not IN the report; it lives in the audit workbook". That is now true of `registerEstimate` only: the
+// notes render on the page, labelled, and the workbook keeps its copy. See render-knockout.mjs's header
+// for the ruling and reviewerNotesBlock for the shape.
 // ── The workbook: the skill's three sheet names + columns, plus the conditional sheets below ────────
 // ── ONE DRILL-THROUGH KEY: `<MARK> #<ordinal>`, per mark ──────────────────────────────────────
@@ -250,9 +254,11 @@ export async function buildKnockoutWorkbook(findings, receipts, outPath, registe
 // ── The email: a COVER NOTE. Headline band, one line per mark, the report link. Nothing else. ────────
 // The report is the deliverable and the email points at it — the same doctrine the clearance lane
 // follows. The old `delivery.email === 'table'` overlay inlined the full review table into the mail
-// body, and it inlined the INTERNAL variant: purple staff notes and the model's register estimate went
-// out over the wire to whoever the mail reached. A second rendering of the findings in a second dialect
-// is also a second thing to keep true. Per-lawyer client formatting is drafted by the assistant from the
+// body, which put the findings in front of whoever the mail reached rather than whoever opened the
+// report, and made a second rendering of them in a second dialect — a second thing to keep true.
+// (That overlay's other charge, that it shipped an INTERNAL variant, no longer describes anything: the
+// 2026-09-07 ruling put the reviewer's notes on the one report. The reason above is the load-bearing one
+// and it is unaffected — the mail stays a cover note.) Per-lawyer client formatting is drafted by the assistant from the
 // run's report-data.json, not by a template knob in here.
 // `reports` is publishKnockout's own list — `[{mark, url}]`, one per published document — and
 // `auditUrl` is composed by the publisher from the pool URL it already holds. Neither is derived here.
@@ -358,6 +364,12 @@ export async function publishKnockout({ runId, codename, runDir, findings, plan,
   let registerRecords = null;
   try { registerRecords = JSON.parse(readFileSync(driverDir(runDir, 'register-records.json'), 'utf8')); }
   catch { registerRecords = null; }
+  // The owner lookups this run made (tracker issue 276), read the same tolerant way as the records above:
+  // an archived run that predates the lane has no file, and its cards then render exactly as they were
+  // delivered. The source line the report prints comes from HERE, not from anything the seat typed.
+  let ownerChecks = [];
+  try { ownerChecks = JSON.parse(readFileSync(driverDir(runDir, 'owner-checks.json'), 'utf8')).checks ?? []; }
+  catch { ownerChecks = []; }
   // ── — THIS LANE HAD NO RECORD-ORIGIN LOGIC AT ALL ─────────────────────────────────────────────
   //
@@ -473,12 +485,22 @@ export async function publishKnockout({ runId, codename, runDir, findings, plan,
   // "every audit link we have ever emailed died at the front door, silently". It came back here twice:
   // once as string surgery on the report URL, once as this function, and both spelled a pool path.
   //
-  // A SINGLE MARK KEEPS THE LEGACY SHAPE. `<runId>/report.html` is what the rewrite exists for, it is
-  // the address in every knockout email already sent, and it resolves. Changing a link that works to
-  // match one that did not is how the next one of these gets written.
+  // A SINGLE MARK USED TO KEEP THE LEGACY SHAPE, on the reasoning that `<runId>/report.html` is what the
+  // rewrite exists for and that it resolves. THAT IS FALSE ON PRODUCTION (tracker issue 289) and the
+  // paragraph is kept, corrected, because its warning is still the right instinct and only its premise
+  // was wrong.
+  //
+  // Settled by the account owner against the live deployment, signed in as a delivered run's own owner:
+  // the emailed link returned the portal application's own `{"error":"not_found"}` — the app answered, so
+  // no rewrite touched the path — while the portal's own link for that run opened. The edge block this
+  // reasoning rests on is not in this repository, and the transcription of it in the test tree describes
+  // a host at the moment somebody wrote it down, not production today.
+  //
+  // The warning it ends with — changing a link that works to match one that did not — is why this was
+  // checked against the live thing before being changed rather than after.
   const origin = poolUrl ? String(poolUrl).replace(/\/$/, '') : null;
   const reportUrlFor = (slug) => !origin ? null
-    : single ? `${origin}/${runId}/report.html`
+    : single ? reportRouteFor(origin, runId)
     : markReportRouteFor(origin, runId, slug);
   // — resolved once for the whole publish, off the same two sources the clearance
   // publisher uses (frozen sidecar, then roster; either marks, neither un-marks).
@@ -512,7 +534,7 @@ export async function publishKnockout({ runId, codename, runDir, findings, plan,
     };
     const markBand = single ? overall : worstBand(framework, [m]);
     writeRO(file, renderKnockoutHtml(one, framework, {
-      runId, overall: markBand, issued, auditFile, probeRan, registerCounts, registerRecords, identity, matter: runId,
+      runId, overall: markBand, issued, auditFile, probeRan, registerCounts, registerRecords, ownerChecks, identity, matter: runId,
       // — an invented mark says so on its own report. Resolved ONCE above the loop:
       // the answer is a property of the run, and asking per mark would let a multi-mark demo mark some
       // documents and not others if the roster moved mid-publish.
@@ -528,7 +550,7 @@ export async function publishKnockout({ runId, codename, runDir, findings, plan,
     // native-render path has been reading for since before anything wrote it. One per report, so the
     // native render of a per-mark document is that mark's data and not the batch's.
     writeRO(dataFile, JSON.stringify(knockoutReportData(one, framework, {
-      runId, codename, overall: markBand, issued, registerCounts, registerRecords, auditFile, customerKey, matter: runId,
+      runId, codename, overall: markBand, issued, registerCounts, registerRecords, ownerChecks, auditFile, customerKey, matter: runId,
       identity: { ...identity, level: searchPolicy?.level ?? null },
       url: reportUrlFor(slug),
     }), null, 2));
@@ -628,7 +650,7 @@ export async function publishKnockout({ runId, codename, runDir, findings, plan,
     // WHICH DOCUMENTS THIS RUN PUBLISHED, and for which name. Every reader that has to open,
     // serve or link a knockout's reports takes the list from here rather than deriving a filename: the
     // naming rule (one mark ⇒ `report.html`, several ⇒ `report-<slug>.html`) is written ONCE, above, and
-    // nobody re-implements it. Absent on every pre- meta, which is exactly the run that has one
+    // nobody re-implements it. Absent on every pre-change meta, which is exactly the run that has one
     // report at `report.html` — so a reader that falls back to that name on absence is reading the
     // archive correctly, not guessing.
     // — `slug` RIDES. It was destructured away here while being computed twenty lines up, and

package/driver/publish/parse.mjs CHANGED Viewed

@@ -225,11 +225,11 @@ export function stripTelemetry(md) {
     .join('\n');
 }
-// ── tracker issue 831 — THE CLIENT CUT OF THE AUDIT BLOCK'S CROSS-REFERENCE LINES ────────────────────────────────
+// ── THE CLIENT CUT OF THE AUDIT BLOCK'S CROSS-REFERENCE LINES ────────────────────────────────
 //
 // `disposition` is a PLACEMENT key. stages.mjs dictates it as the posture that sets only WHERE a card is
 // placed and never the band; findings-model's DISPOSITION_GROUP maps it to the section heading the report
-// already prints. tracker issue 762 D5 took it off the report's risk chip and tracker issue 833 added the `disposition` KEY to
+// already prints. D5 took it off the report's risk chip and a later change added the `disposition` KEY to
 // scrubCards' strip list — and the word still reached client principals, because audit-from-spine.mjs
 // re-encodes it into two OTHER keys that survive an allowlist keyed on names:
 //
@@ -252,7 +252,7 @@ export function stripTelemetry(md) {
 // resolved to, and which fragment of a contradicted pair the record supports. Deleting the key deletes the
 // pointer along with the word.
 //
-// THIS IS NOT THE SUBSTITUTION tracker issue 669 FORBIDS. Nothing here reads arbitrary client prose for a vocabulary.
+// THIS IS NOT THE FORBIDDEN SUBSTITUTION. Nothing here reads arbitrary client prose for a vocabulary.
 // Each rule is ANCHORED to one position in a grammar THIS ENGINE writes: the disposition token at the head
 // of `resolution`, and the disposition token inside the `(finding #N, …)` parenthetical the contradiction
 // line builds. A mark named ADVERSARIAL survives both — it is not at position 0 of a resolution line, and
@@ -290,7 +290,7 @@ export function contradictionResolutionForClient(v) {
   return String(v).replace(CONTRADICTION_DISPOSITION_RE, '$1)');
 }
-// ── tracker issue 669 — ENGINE_PLAIN AND plainify ARE DELETED ────────────────────────────────────────────────────
+// ── ENGINE_PLAIN AND plainify ARE DELETED ────────────────────────────────────────────────────
 //
 // doc-52 put nineteen find-and-replace rules on the rendered client surface. tracker issue 656 is what that cost:
 // `axis` -> `group` turned "AXIS Bank filed in class 36" into "group Bank filed in class 36" — a report

package/driver/publish/publish-inputs.mjs CHANGED Viewed

@@ -19,7 +19,7 @@
 //
 // Modelled on mcp-server/lib/coverage.mjs:65-75 (assertValidatorCoverage): a closed partition asserted
 // at LOAD, so a new store cannot be added without consciously choosing its gating. The failure that
-// mechanism exists to prevent is 's — a hand-copied mirror that silently stopped covering an
+// mechanism exists to prevent is the — a hand-copied mirror that silently stopped covering an
 // artifact and still answered "complete: yes" about a file it never checked.
 import { existsSync, readFileSync } from "node:fs";
@@ -93,7 +93,7 @@ export const NOT_READ_BY_NAME = {
   "token-ledger": "the per-recipe token rollup, read through tokens.mjs rollupTokens(runDir) which walks the run's own telemetry; absent ⇒ the meta simply omits the tokens field",
 };
-// Neither of these is a run-side store, and both have been miscounted as one ('s own issue body
+// Neither of these is a run-side store, and both have been miscounted as one (its own issue body
 // lists audit.md among the stores publishReport reads). They are FUNCTION ARGUMENTS — publishReport is
 // handed the two contract markdown paths by its caller and reads them from wherever it is told, so an
 // absent one is the caller's error and already throws. Declared so the source scan can tell "argument"

package/driver/publish/register-presence.mjs CHANGED Viewed

@@ -2,7 +2,7 @@
 // Copyright 2026 Cordillera Sàrl. Additional terms under section 7 of the AGPL-3.0 apply — see ADDITIONAL-TERMS.md
 // register-presence.mjs — the audit's queryable store of every live, matter-in-scope enumerated record.
 //
-// THE RULING THIS IMPLEMENTS (, owner 2026-08-31): "YES of course they should be in
+// THE RULING THIS IMPLEMENTS (owner 2026-08-31): "YES of course they should be in
 // the audit. always. … we don't need to report on them but we need to store them." On the run this was
 // measured against, 65 live records inside the matter's scope and carrying the client's own dominant
 // element appeared in NO stored artifact — not the report (correct), and not the audit either (the

package/driver/publish/render-knockout.mjs CHANGED Viewed

@@ -21,10 +21,20 @@
 // ~60 lines of duplicated document shell, and it is the right price: the alternative is exporting the
 // shell out of the frozen file, which is a bigger break than the duplication saves.
 //
-// ONE report. There is no client variant and no internal variant. What used
-// to render purple — the staff notes and the model's register estimate — is not stripped here, it is
-// simply NOT PART OF THE REPORT; it lives in the audit workbook, which is where internal working material
-// belongs. That removes the whole class of "the wrong link got sent".
+// ONE report. There is no client variant and no internal variant, and that is
+// still the rule — it is what removes the whole class of "the wrong link got sent".
+//
+// WHAT CHANGED, 2026-09-07 (owner ruling, tracker issue 274): the one report now CARRIES the reviewer's
+// notes rather than routing them to the audit workbook alone. The earlier reading of "one report" was
+// that internal working material is simply not part of it; the ruling is that there is one report and the
+// person who ran Clearotron reads it, so holding material back "just adds confusion for where data is
+// lost". Six notes written for the reviewing lawyer on a delivered run reached the spreadsheet and
+// nothing else, which is the measurement behind the ruling.
+//
+// So: the notes render, LABELLED, in report.css's existing `.internal` purple convention (see
+// reviewerNotesBlock) — never merged into the client-voiced body. The workbook keeps them as well; this
+// added a surface and moved none. The model's `registerEstimate` is NOT covered by the ruling and stays
+// off the page.
 import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -118,7 +128,7 @@ function bandStop(framework, band) {
 const DEGRADED_NOTE = 'Automated research for this name was unavailable — manual verification is recommended before relying on this rating.';
-// tracker issue 760 — THE QUALIFIER, IN WORDS. It rendered as a bare grey token under the band chip — `low`, no
+// THE QUALIFIER, IN WORDS. It rendered as a bare grey token under the band chip — `low`, no
 // label, no border, nothing on the page saying what it qualified. A reader met one word of a private
 // vocabulary and had to guess whether it described the risk, the confidence or the search.
 //
@@ -176,6 +186,14 @@ const KO_CSS = `
   .ko-findev{margin:0;font-size:12.5px;line-height:1.6;word-break:break-word}
   .ko-count{font-family:var(--mono);font-size:13px;color:var(--ink);margin:0}
   .ko-degraded{font-size:13px;color:var(--med-tx,#82550A);margin:8px 0 0;font-style:italic}
+  /* The reviewer-notes legend. NOT .ko-legend — that name is taken by the framework attribution row
+     above, and reusing it would restyle the caption. It names the purple convention report.css already
+     draws for .internal, so the colour is stated once and never re-specified. */
+  .ko-refnote{margin:0;padding:11px 24px 0;font-size:12px;color:#6a2b6e;font-style:italic}
+  /* The notes sit inside a mark's column, so the shared .internal block's bullets keep the column's
+     own list indent and do not fight the paragraph above them. */
+  .ko-row .internal .ko-bul{margin:0 0 4px}
+  .ko-row .internal .ko-bul:last-child{margin-bottom:0}
   .ko-counts table{width:100%;border-collapse:collapse;font-size:14px}
   .ko-counts th{text-align:left;font-size:10.5px;letter-spacing:.06em;text-transform:uppercase;color:var(--faint);
     font-weight:700;padding:14px 24px 8px;border-bottom:1px solid var(--line)}
@@ -248,13 +266,13 @@ function glanceSection(marks, framework, registerCounts) {
       </div>
     </div>`;
   }).join('');
-  // tracker issue 761 — THE FRAMEWORK IS NAMED BESIDE THE CHIPS IT EXPLAINS. Every `.ko-band` chip below speaks one
+  // THE FRAMEWORK IS NAMED BESIDE THE CHIPS IT EXPLAINS. Every `.ko-band` chip below speaks one
   // word out of a framework's vocabulary, and that framework was named exactly once on this page: in the
   // footer, under everything it governs. This is ATTRIBUTION AND NOTHING ELSE — the same "Rated under
   // <name>" the footer prints, moved to where the words it licenses are actually read.
   //
   // NO LADDER HERE. Spelling the band scale out beside the chips would be new furniture on a client
-  // deliverable, and tracker issue 765 rules that a rung buys depth, never furniture. If the knockout reader needs the
+  // deliverable, and a rung buys depth, never furniture. If the knockout reader needs the
   // scale, that is its own decision on its own merits, not a rider on this one.
   //
   // No framework ⇒ NOTHING. A run this render was given no manifest for gets no attribution invented for
@@ -637,6 +655,28 @@ const REGISTER_ORDINAL_FLOOR = 900;
 export const NOT_WEIGHED_LINE = 'Register listing — this card carries no rating of its own';
 const NOT_WEIGHED = NOT_WEIGHED_LINE;
+/**
+ * The register card's basis line, which cannot be written without knowing whether the card is rated.
+ *
+ * THE TWO RULINGS MEET HERE AND THEY ALMOST CONTRADICTED EACH OTHER ON A CLIENT PAGE. tracker issue
+ * 1935 retired a code-owned placeholder because a rating nobody performed must not appear; tracker
+ * issue 274 then ruled that the rater's OWN band for a promoted filing must appear, because a filing
+ * the rater weighed into the verdict was rendering as though it had not been. Both hold, and they hold
+ * over different cards.
+ *
+ * `band` and `read` are independent fields — the band comes from `registerReads[].band` and the read
+ * from its `text` — so a filing the rater banded WITHOUT typing a read is reachable, and the first cut
+ * of this rendered the band chip beside the sentence "this card carries no rating of its own". The
+ * report would have been contradicting itself in one card, in the client's voice.
+ *
+ * So: the retired line belongs only to a card with no band. A banded card with no read says nothing
+ * rather than something false — the chip and the source tag already say what the card is.
+ */
+function basisLine(band, read) {
+  if (read) return `<p class="ko-findbasis">${esc(read)}</p>`;
+  return band ? '' : `<p class="ko-findbasis">${esc(NOT_WEIGHED)}</p>`;
+}
 /**
  * Which listed filings get pointed at. TWO tests, and both fail OPEN — a filing is promoted unless
@@ -654,7 +694,11 @@ const NOT_WEIGHED = NOT_WEIGHED_LINE;
  * Neither test is a judgment about the filing. Whether any of it blocks anything is lawyer work this
  * product does not do — the same line register-records.mjs rule 3 has held since the lane shipped.
  */
-function promotableRecords(entry, mark) {
+// EXPORTED so the pipeline can ask the same question the page asks (tracker issue 276). The owner
+// use-check runs on PROMOTED filings only, and "promoted" has to mean here what it means on the report —
+// a second predicate would let the engine search an owner whose filing the report never shows, or skip
+// one it does.
+export function promotableRecords(entry, mark) {
   const scope = new Set([...(mark?.classesSearched ?? []), ...(entry?.classes ?? [])]
     .map(Number).filter(Number.isInteger));
   return (entry?.records ?? []).filter((r) => {
@@ -728,9 +772,13 @@ function registerCardViews(mark, framework, registerRecords) {
  * is gone; what tells the two apart on the page is where the finding came from, which is the vocabulary
  * the clearance reports already use for exactly this.
  *
- * NO BAND CHIP AND NO `bandStop`, still, and for the reason the old note gave: a rung of the run's ladder
- * here would be a rating nobody performed. The rail takes --faint so the card reads off the risk ramp
- * rather than on it.
+ * THE BAND CHIP IS DRAWN ONLY WHEN THE RATER SENT ONE, and that condition is the whole rule. The old note
+ * here said "no band chip and no `bandStop`, ever: a rung of the run's ladder would be a rating nobody
+ * performed" — which was true for as long as nothing could carry the rater's rating of an individual
+ * filing. `registerReads[].band` now can (tracker issue 274), so the objection is answered where it was
+ * raised: with a band, the rating WAS performed, by the seat, in the framework's own words, and the chip
+ * states it. With no band the old rule stands unchanged — --faint rail, no chip, nothing claimed — and
+ * that is still what every archived run renders.
  *
  * THE LINE UNDER THE STATEMENT DESCRIBES THE CARD, NOT THE RATING. It used to deny
  * that the rating turned on this filing, which this function has no way to know and which a delivered
@@ -759,28 +807,83 @@ function sourceChips(v) {
   return `${commonLaw ? '<span class="src cl">Common law</span>' : ''}${register ? '<span class="src reg">Register</span>' : ''}`;
 }
-function registerFindingBlock(v, markIndex, reads = null) {
+// ── THE REVIEWER'S NOTES, ON THE REPORT ─────────────────────────────────────────────────
+//
+// OWNER RULING, 2026-09-07: there is one report and the person who ran Clearotron reads it — keeping
+// this material off the page "just adds confusion for where data is lost". This replaces the earlier
+// split under which the notes went to the audit workbook alone (the header of this file and
+// publish/knockout.mjs carried that rule; both now say what replaced it). The workbook keeps them too:
+// this adds a surface, it does not move one.
+//
+// LABELLED, NEVER MERGED. They render in the established `.internal` purple convention report.css
+// already defines — the same one the clearance report uses for this material — so a reader can see whose
+// voice a line is in. Merging them into the client-voiced body would make the reviewer's asides read as
+// findings about the mark, which is the one way this ruling could produce a worse document.
+const REVIEWER_NOTES_LEGEND = 'Information for your reference/context that likely does not need to be shared with the business is shown in purple.';
+// The clearance lane's own label, copied rather than re-worded (tracker issue 276). One spelling across
+// both products is the point: a reader who has seen it on a clearance report knows what it means here.
+const USE_CHECK_LABEL = 'Use-check source:';
+/** The owner lookup covering a filing, joined by recordId. `null` when this run owed that filing none. */
+function ownerCheckFor(ownerChecks, recordId) {
+  const id = String(recordId ?? '').trim();
+  if (!id) return null;
+  return (Array.isArray(ownerChecks) ? ownerChecks : [])
+    .find((c) => (Array.isArray(c?.recordIds) ? c.recordIds : []).some((x) => String(x).trim() === id)) ?? null;
+}
+function reviewerNotesBlock(m) {
+  const notes = (Array.isArray(m?.purpleNotes) ? m.purpleNotes : [])
+    .map((n) => String(n ?? '').trim()).filter(Boolean);
+  if (!notes.length) return '';
+  return `<div class="internal">
+            <span class="tag">For your reference</span>
+            ${notes.map((n) => `<p class="ko-bul">${inlineMd(n)}</p>`).join('')}
+          </div>`;
+}
+function registerFindingBlock(v, markIndex, reads = null, framework = null, ownerChecks = []) {
   const r = v.record;
   // — THE RATER'S OWN READ OF THIS FILING, when it recorded one. `registerReads` is
   // joined to the record store by the validator, so a row that reaches here names a filing this run
   // actually holds. With no row the neutral line stands, and the neutral line is TRUE: it describes the
   // card. That is why the field can be optional without the page ever asserting something false.
-  const read = (Array.isArray(reads) ? reads : [])
-    .map((x) => ({ id: String(x?.recordId ?? '').trim(), text: String(x?.read ?? '').trim() }))
-    .find((x) => x.id && x.id === String(r?.recordId ?? '').trim())?.text;
+  const row = (Array.isArray(reads) ? reads : [])
+    .map((x) => ({ id: String(x?.recordId ?? '').trim(), text: String(x?.read ?? '').trim(), band: String(x?.band ?? '').trim() }))
+    .find((x) => x.id && x.id === String(r?.recordId ?? '').trim());
+  const read = row?.text;
+  // The band rides the SAME row as the read and is independently optional: a read with no band prints
+  // exactly as it did before this field existed. The validator has already checked the word against the
+  // frozen ladder, so `bandStop` resolves a real stop rather than falling through to a default that would
+  // colour an unknown word as though it were rated.
+  const band = row?.band || null;
+  const stop = band ? bandStop(framework, band) : null;
+  // ── WHERE THE OWNER'S TRADE WAS LOOKED UP (tracker issue 276) ──────────────────────────────────
+  //
+  // The source is the DRIVER'S, joined by this filing's own recordId — never a URL the seat typed. That
+  // is the whole reason a reader can trust it: the row exists because the driver made the call, so
+  // "asserting a no-result without issuing a query" is not a thing this surface can express.
+  //
+  // ABSENT ON A RUN THAT OWED NO CHECK, and that silence is correct: no line at all says nothing, while
+  // a line reading "no result" on a filing nobody was asked about would claim a search that never ran.
+  const useCheck = ownerCheckFor(ownerChecks, r?.recordId);
+  const useCheckSource = useCheck?.source ?? null;
   const meta = [r.owner ? esc(r.owner) : 'proprietor not stated', r.territory ? esc(r.territory) : null]
     .filter(Boolean).join(' · ');
   const receipt = isHttpUrl(r.url) ? linkOrText(r.url) : esc(r.recordId ?? 'no record address supplied');
   return `<div class="card ko-find" data-ko-mark="${Number(markIndex)}" data-ko-ord="${Number(v.ordinal)}">
         <div class="top">
-          <div class="rail" style="background:var(--faint)"></div>
+          <div class="rail" style="background:var(${stop ?? '--faint'})"></div>
           <div class="body">
             <div class="cardhead">
-              <span class="fnum">${esc(v.ref)}</span><span class="who">${esc(r.mark ?? 'Unnamed filing')}</span><span class="src reg">Register</span>
+              <span class="fnum">${esc(v.ref)}</span><span class="who">${esc(r.mark ?? 'Unnamed filing')}</span>${
+    band ? `<span class="ko-findband" style="background:var(${stop})">${esc(band)}</span>` : ''}<span class="src reg">Register</span>
             </div>
             <p class="ko-findmeta">${meta}</p>
             <p class="ko-findnet">${esc(v.statement)}</p>
-            <p class="ko-findbasis">${esc(read || NOT_WEIGHED)}</p>
+            ${basisLine(band, read)}
+            ${useCheck ? `<p class="ko-findev">${esc(USE_CHECK_LABEL)} ${isHttpUrl(useCheckSource) ? linkOrText(useCheckSource) : esc(useCheckSource)}</p>` : ''}
             <p class="ko-findev">Register record: ${receipt}</p>
           </div>
         </div>
@@ -916,7 +1019,7 @@ function readBlock(m) {
   ].filter(Boolean).join('');
 }
-function analysisSection(marks, framework, { registerCounts = null, probeRan = false, registerRecords = null } = {}) {
+function analysisSection(marks, framework, { registerCounts = null, probeRan = false, registerRecords = null, ownerChecks = [] } = {}) {
   const cards = marks.map((m, markIndex) => {
     const stop = bandStop(framework, m.rating);
     const bullets = readBlock(m);
@@ -925,7 +1028,7 @@ function analysisSection(marks, framework, { registerCounts = null, probeRan = f
     // under compareKnockoutBlockingPower, so appending them is the ladder's own rule applied to a row
     // that has no rung, not a new one invented for the register.
     const reg = registerCardViews(m, framework, registerRecords);
-    const regBlocks = reg.cards.map((v) => registerFindingBlock(v, markIndex, m?.registerReads)).join('');
+    const regBlocks = reg.cards.map((v) => registerFindingBlock(v, markIndex, m?.registerReads, framework, ownerChecks)).join('');
     const overflow = reg.promoted > reg.cards.length
       ? `<p class="ko-bul">${esc(`${reg.promoted - reg.cards.length} further filing${reg.promoted - reg.cards.length === 1 ? '' : 's'} for this name met the same test — every one of them is in the filings section below.`)}</p>`
       : '';
@@ -950,11 +1053,17 @@ function analysisSection(marks, framework, { registerCounts = null, probeRan = f
       <div>
         ${body || '<p class="ko-bul">No adverse signals recorded for this name on this screen.</p>'}
         ${m.degraded ? `<p class="ko-degraded">${esc(DEGRADED_NOTE)}</p>` : ''}
+        ${reviewerNotesBlock(m)}
         <p class="ko-reg">${esc(registerLine(m, registerCounts, probeRan, registerRecords, reg.cards))}</p>
       </div>
     </div>`;
   }).join('');
-  return `<div class="panel ko-glance">${cards}</div>`;
+  // The legend rides the panel and only when a note is actually on it — a standing sentence explaining a
+  // colour no reader can see would be the report describing a convention it did not use.
+  const anyNotes = marks.some((m) => (Array.isArray(m?.purpleNotes) ? m.purpleNotes : [])
+    .some((n) => String(n ?? '').trim()));
+  const legend = anyNotes ? `<p class="ko-refnote">${esc(REVIEWER_NOTES_LEGEND)}</p>` : '';
+  return `<div class="panel ko-glance">${legend}${cards}</div>`;
 }
 // The method line names EXACTLY what ran, and its wording is doctrine — with counts on the page, "register
@@ -1114,6 +1223,9 @@ function methodLine(registerCounts, probeRan, { citedFindings = 0, uncitedFindin
 export function renderKnockoutHtml(findings, framework, {
   runId, overall, issued = null, auditFile = null, probeRan = false, registerCounts = null,
   registerRecords = null,
+  // The driver's own record of the owner lookups it ran (tracker issue 276). Defaults to [] so an
+  // archived run that predates the lane renders exactly as it was delivered.
+  ownerChecks = [],
   identity = null, matter = null, homeHref = null, chromeHref = null, depthNote = null,
   // — the run's FROZEN policy, so the scope section states what this run was
   // instructed to do rather than what its artifacts happen to show. Defaults to null, and an archived
@@ -1154,7 +1266,7 @@ export function renderKnockoutHtml(findings, framework, {
   const counts = hasCounts
     ? countsSection(marks, registerCounts)
     : `<div class="panel"><p class="ko-tier">${esc(tierLine)}</p></div>`;
-  const analysis = analysisSection(marks, framework, { registerCounts, probeRan, registerRecords });
+  const analysis = analysisSection(marks, framework, { registerCounts, probeRan, registerRecords, ownerChecks });
   const provider = hasCounts ? (registerCounts.providerLabel ?? registerCounts.provider ?? 'the register') : null;
   // The filings appendix renders only when the run produced a listing artifact — never on its absence,
   // and never as an empty table. A knockout with no sidecar publishes exactly the counts-only document.
@@ -1282,7 +1394,7 @@ window.addEventListener('beforeprint',o);})();</script>
  * where the working notes live, and a data file that quietly re-admitted them would reopen exactly the
  * leak this series closed.
  */
-export function knockoutReportData(findings, framework, { runId, codename, overall, issued, identity, registerCounts, registerRecords = null, url, auditFile, customerKey, matter }) {
+export function knockoutReportData(findings, framework, { runId, codename, overall, issued, identity, registerCounts, registerRecords = null, ownerChecks = [], url, auditFile, customerKey, matter }) {
   const marks = findings?.marks ?? [];
   return {
     schema: 'report-data/1',
@@ -1324,6 +1436,39 @@ export function knockoutReportData(findings, framework, { runId, codename, overa
         classesDriving: m.classesDriving ?? [],
         degraded: Boolean(m.degraded),
         points: m.bullets ?? [],
+        // ── THE ASSESSMENT THE RUN ALREADY WROTE (tracker issue 274) ──────────────────────────────
+        //
+        // Seven keys the assess stage writes into knockout-findings.json reached this file as nothing.
+        // They were not withheld by a rule — no code decided against them; this projection is an explicit
+        // whitelist and nobody had added them, so an assistant drafting from this file could not see the
+        // reasoning behind a rating it was drafting about.
+        //
+        // `assessment` is the sharpest case: publish substitutes it into `batch.executiveSummary` ONLY on
+        // a multi-mark batch, so on a single-mark run — the common knockout — the mark's own opening read
+        // was written, validated, and then dropped by both surfaces at once.
+        //
+        // `purpleNotes` is the reviewer's notes, and it is here by the owner's ruling of 2026-09-07: one
+        // report, read by the person who ran Clearotron, because keeping material off it "just adds
+        // confusion for where data is lost". They are LABELLED on the page rather than merged into the
+        // client-voiced body — see reviewerNotesBlock — so a reader can tell whose voice they are in.
+        assessment: (() => { const t = String(m.assessment ?? '').trim(); return t || null; })(),
+        counterFactors: m.counterFactors ?? [],
+        mitigation: (() => { const t = String(m.mitigation ?? '').trim(); return t || null; })(),
+        // `null`, not `false`, when the rater said nothing: a crowded field is a mitigant the reasoning
+        // turns on, and an unstated one must not read as a stated "no".
+        crowdedField: typeof m.crowdedField === 'boolean' ? m.crowdedField : null,
+        reviewerNotes: m.purpleNotes ?? [],
+        // The proof-of-search rows — the same defensibility record list_searches answers from.
+        negatives: (m.negatives ?? []).map((n) => ({
+          term: n?.term ?? null, source: n?.source ?? null, note: n?.note ?? null,
+        })),
+        // The rater's read of a filing it weighed, keyed by the record id the card prints, so a consumer
+        // can join a read to its filing without matching on prose.
+        registerReads: (m.registerReads ?? []).map((x) => ({
+          recordId: x?.recordId ?? null,
+          read: x?.read ?? null,
+          band: String(x?.band ?? '').trim() || null,
+        })),
         // — the typed finding, ranked, with the reference the report prints. The old key was
         // `evidence[]` and it was `(m.findings ?? []).filter((f) => f?.url)`: a typed finding has no
         // `url`, so this file — the one the assistant drafts client mail from — silently carried zero
@@ -1345,14 +1490,36 @@ export function knockoutReportData(findings, framework, { runId, codename, overa
           //     A promoted filing the brief omitted would be the report and the brief disagreeing about
           //     what the run found.
           //
-          // `band: null` and `shape: 'register'` are the load-bearing fields: a consumer can tell a
-          // weighed conflict from a pointed-at filing without parsing prose, and `net` carries the
-          // not-weighed sentence so a consumer that reads only `net` still cannot overstate it.
-          ...registerCardViews(m, framework, registerRecords).cards.map((v) => ({
-            ref: v.ref, ordinal: v.ordinal, name: v.record.mark, owner: v.record.owner, band: null,
-            type: 'Register filing', net: `${v.statement} It was ${NOT_WEIGHED}.`, basis: NOT_WEIGHED,
-            evidence: v.evidence, shape: 'register',
-          })),
+          // `shape: 'register'` is the load-bearing field: a consumer can tell a weighed conflict from a
+          // pointed-at filing without parsing prose.
+          //
+          // `band` AND `basis` NOW CARRY THE RATER'S READ WHEN IT SENT ONE (tracker issue 274). Before
+          // this, both were constants — `band: null` and the not-weighed sentence — on every filing of
+          // every run, including runs where the seat had written a full read of that exact filing and the
+          // HTML card was already printing it. The page and this file disagreed, and this file is the one
+          // the MCP brief answers from, so the surface a reader asks "what did you make of that
+          // registration?" was the surface that had dropped the answer.
+          //
+          // The unmatched case is unchanged and must stay that way: no row for this recordId ⇒ `band:
+          // null` and the not-weighed line, which describes the card and claims nothing.
+          ...registerCardViews(m, framework, registerRecords).cards.map((v) => {
+            const row = (Array.isArray(m?.registerReads) ? m.registerReads : [])
+              .find((x) => String(x?.recordId ?? '').trim() && String(x?.recordId ?? '').trim() === String(v.record?.recordId ?? '').trim());
+            const read = String(row?.read ?? '').trim() || null;
+            const band = String(row?.band ?? '').trim() || null;
+            // The driver's own record of where this filing's proprietor was looked up (tracker issue
+            // 276), joined by recordId. `null` where the run owed no check — the same three states the
+            // card has, so a consumer can tell "searched and found nothing" from "never searched".
+            const oc = ownerCheckFor(ownerChecks, v.record?.recordId);
+            return {
+              ref: v.ref, ordinal: v.ordinal, name: v.record.mark, owner: v.record.owner, band,
+              type: 'Register filing',
+              net: read ? v.statement : `${v.statement} It was ${NOT_WEIGHED}.`,
+              basis: read ?? NOT_WEIGHED,
+              useCheckSource: oc?.source ?? null,
+              evidence: v.evidence, shape: 'register',
+            };
+          }),
         ],
         registerCounts: counted?.counts
           ? {

package/driver/publish/report-data.mjs CHANGED Viewed

@@ -4,9 +4,19 @@
 // report-data.json since the one-report collapse; the clearance lane's native-render branch existed in
 // the portal with NO producer anywhere (B3's "the aspirational path") — this is that producer.
 //
-// Two readers, one file (the knockout doctrine, verbatim): the assistant drafts client-facing mail from
-// it, and the portal's native-render path reads it instead of iframing baked HTML. It is the CLIENT CUT
-// by construction, not by serve-time stripping:
+// Two readers, one file (the knockout doctrine, as it stood): the assistant drafts client-facing mail
+// from it, and the portal's native-render path reads it instead of iframing baked HTML.
+//
+// THE TWO LANES DIVERGED ON 2026-09-07 AND THIS FILE DID NOT MOVE. The owner ruled (tracker issue 274)
+// that the KNOCKOUT report carries the reviewer's notes, on the ground that one report is read by the
+// person who ran Clearotron and holding material back confuses where data went; render-knockout.mjs
+// projects them under `reviewerNotes`. That ruling was about those notes on that lane. It did not touch
+// what this producer strips — withdrawn findings, verification receipts, `::p::` tails, `[internal]`
+// labels and engine-internal narration are all still cut here, and the guard test still polices them.
+// Do not read the knockout change as licence to relax this list; if the ruling is meant to extend, it
+// extends by being asked, not by inference.
+//
+// It remains the CLIENT CUT by construction, not by serve-time stripping:
 //   • only LIVE findings (a withdrawn finding renders nowhere — it does not exist here either);
 //   • no verification receipts (use_check / own_rights / bears_on — those are the reviewer's evidence
 //     trail and live in the audit workbook), no withdrawn_reason, no quarantine records;