clearotron 0.2.1 → 0.2.3

package/driver/publish/render-knockout.mjs

@@ -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';
@@ -35,7 +45,7 @@ import {
 import { SUMMARY_BLOCK_LINE, parseSummaryBlocks } from '../../shared/summary-blocks.mjs';
 import { COUNT_BASIS, COUNT_PREDICATES, countsForMark, countLine, variantFormsLine } from '../register-count.mjs';
 import { RECORD_BASIS, recordsForMark, recordsLine } from '../register-records.mjs';
-import { knockoutFindingViews } from '../findings-model.mjs';
+import { knockoutFindingViews, splitKnockoutNotes } from '../findings-model.mjs';
 import { demoBannerHtml } from './render.mjs';   // — the SAME banner the clearance template renders, not a second wording
 // — the two facts the register card is allowed to read off a raw record, and NEITHER is minted
 // here. `makeClassifyStatus` and `isAllClass` are the screening lane's own, already shipped, already
@@ -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)}
@@ -202,6 +220,28 @@ const KO_CSS = `
      saved to PDF would drop the narrative this block exists to preserve. The beforeprint handler below
      opens them; this hides the now-pointless toggle in print. */
   @media print{.ko-full summary{display:none}}
+  /* THE LABELS THE READER ACTUALLY READS. ko-lbl above is 9.5px uppercase grey — the owner's
+     "what holds what?" was asked of a label in that style, so a new word in the same style is the
+     same defect with different letters. These are body size and body colour, and they carry the
+     band's own word ("Why High"), which is what makes them answerable without a legend. */
+  .ko-lbl2{display:block;font-size:14px;font-weight:700;color:var(--ink);margin:0 0 5px;letter-spacing:0}
+  /* The card's fold. ko-full rides with it so openAll() and the beforeprint handler reach it —
+     what folds on screen still prints, which is the rule this template already states for the
+     narrative fold. ko-why carries only the spacing a card needs inside its own body. */
+  .ko-why{margin:6px 0 5px}
+  .ko-why summary{font-size:12px;text-transform:none;letter-spacing:0;color:var(--rose,var(--faint));font-weight:600}
+  /* "About this request" — what was asked, and any flag on the asking. It sits in the hero because a
+     mis-scoped request makes every number below it answer the wrong question. */
+  .ko-req{margin:14px 0 0;padding:13px 16px;border:1px solid var(--line);border-radius:3px}
+  .ko-req .ko-lbl2{margin-bottom:6px}
+  .ko-req p{margin:0 0 6px;font-size:13.5px;color:var(--slate);line-height:1.6}
+  .ko-req p:last-child{margin-bottom:0}
+  .ko-reqflag{border-left:3px solid var(--rose,var(--line));padding-left:11px;margin-top:9px}
+  /* THE PURPLE NOTES COME OFF THE EXPORT, exactly as the clearance page removes its internal notes
+     ("Internal (review-only) notes are removed on export"). The knockout's export is window.print()
+     via exportPDF(), so print is the whole export path and this rule is the whole strip. Without it
+     a knockout PDF forwarded to a client carries the reviewing lawyer's notes. */
+  @media print{.internal{display:none !important}}
   .ko-reg{margin:11px 0 0;padding:8px 0 0;border-top:1px solid var(--line);
     font-family:var(--mono);font-size:12px;color:var(--faint);line-height:1.5}
   .ko-filings{padding:14px 0 2px;border-bottom:1px solid var(--line)}
@@ -248,13 +288,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
@@ -279,8 +319,111 @@ function glanceSection(marks, framework, registerCounts) {
 // all-classes figure alongside a class-scoped one would be a second count — one more provider call per
 // mark per predicate, billable on Corsearch — and that is a spend the owner has not ruled on. Raised as
 // a follow-up rather than assumed here (tracker issue 717).
+// ── TERRITORIES IN WORDS, NEVER CODES (tracker issue 331 C) ─────────────────────────────────────────
+//
+// The line read "territories: EM, US, WO". On a worldwide run the same line printed every register code
+// the provider offers — roughly two hundred, AD through ZZ, internal groupings among them — which the
+// owner called a meaningless list, correctly: a reader cannot tell anything from two hundred codes and
+// cannot tell much from three.
+//
+// TWO CODES ARE REGISTERS RATHER THAN COUNTRIES and neither is an ISO region, so neither can be resolved
+// by a country table: EM is the EU Intellectual Property Office and WO is WIPO's international register.
+// They are named here because they are the two a reader meets constantly.
+//
+// A CODE THIS TABLE CANNOT NAME IS DROPPED, NOT PRINTED. The provider's internal groupings (XA, XG, XS,
+// XW, ZZ and their like) name no register a reader could look up, and printing one is the defect this
+// change exists to remove. Dropping them is safe because the COUNT of registers is stated separately and
+// is taken before any naming — so a reader is never told about fewer registers than were counted.
+// TWO FORMS PER REGISTER, because English needs both: "Counted in the United States" takes the article
+// and "United States application" refuses it. One map with one form produced "the United States
+// application (pending)" on a card, which is why they are separate fields rather than a regex over one.
+const REGISTER_NAMES = Object.freeze({
+  EM: { bare: 'European Union', phrase: 'the European Union' },
+  EU: { bare: 'European Union', phrase: 'the European Union' },
+  WO: { bare: 'international', phrase: 'the WIPO register' },
+  US: { bare: 'United States', phrase: 'the United States' },
+  GB: { bare: 'United Kingdom', phrase: 'the United Kingdom' },
+  UK: { bare: 'United Kingdom', phrase: 'the United Kingdom' },
+  CH: { bare: 'Swiss', phrase: 'Switzerland' },
+});
+
+/**
+ * A register code as a reader's words, or '' when this build cannot name it. NEVER returns a code.
+ * `bare: true` gives the attributive form for a phrase like "United States application".
+ */
+function territoryName(code, { bare = false } = {}) {
+  const c = String(code ?? '').trim().toUpperCase();
+  if (!c) return '';
+  if (REGISTER_NAMES[c]) return bare ? REGISTER_NAMES[c].bare : REGISTER_NAMES[c].phrase;
+  // The provider's internal groupings all sit in the X* and Z* space and name no lookup-able register.
+  if (/^[XZ]/.test(c)) return '';
+  try {
+    const name = new Intl.DisplayNames(['en'], { type: 'region' }).of(c);
+    // Intl hands the CODE back when it knows no region by that name — which would print exactly the
+    // thing this function exists to prevent, so an unresolved code is an empty string.
+    return name && name.toUpperCase() !== c ? name : '';
+  } catch { return ''; }
+}
+
+/** "a, b and c" — the reader's list, not a join on commas. */
+function listWords(items) {
+  const xs = (items ?? []).filter(Boolean);
+  if (xs.length <= 1) return xs[0] ?? '';
+  return `${xs.slice(0, -1).join(', ')} and ${xs[xs.length - 1]}`;
+}
+
+/**
+ * The counted scope, in one sentence (tracker issue 331 C). Three shapes, and the shape is chosen by
+ * how many registers were counted rather than by which they were:
+ *
+ *   every register the provider offers  -> "Counted worldwide, 190 registers, on Clarivate Compumark."
+ *   up to six                           -> named in full
+ *   more than six, not all              -> the count, and where the list is
+ *
+ * The provider is named here and nowhere else on the page; 331 D takes the vendor's name off the cards.
+ */
+const TERRITORY_NAME_CAP = 6;
+function territoriesLine(registerCounts) {
+  const provider = registerCounts?.providerLabel ?? registerCounts?.provider ?? 'the register';
+  const regions = (registerCounts?.scope?.regions ?? []).filter(Boolean);
+  const worldwide = registerCounts?.scope?.worldwide === true || regions.length === 0;
+  if (worldwide) {
+    const n = regions.length;
+    return n
+      ? `Counted worldwide, ${n} registers, on ${provider}.`
+      : `Counted worldwide on ${provider}.`;
+  }
+  const named = regions.map(territoryName).filter(Boolean);
+  if (named.length && named.length <= TERRITORY_NAME_CAP) {
+    return `Counted in ${listWords(named)}, on ${provider}.`;
+  }
+  return `Counted on ${regions.length} registers, listed on the workbook's Register Counts sheet, on ${provider}.`;
+}
+
+/** What the counts do and do not say — the one line that replaces the count-basis paragraph on the page. */
+const COUNTS_READER_LINE = 'Counts include live, pending and dead filings. '
+  + 'A count is not a conflict; the cards above say which filings matter.';
+
 function countsSection(marks, registerCounts) {
-  const head = COUNT_PREDICATES.map((p) => `<th>${esc(p.label)}</th>`).join('');
+  // ── THE DEFINITION MOVES INTO THE COLUMN HEADER (tracker issue 331 B) ────────────────────────────
+  //
+  // The 70-word count-basis paragraph existed because three one-word headers — Identical, Containing,
+  // Close variations — did not say what they counted, so the definition had to go somewhere. Put it in
+  // the header and the paragraph has nothing left to do.
+  //
+  // ONE NAME ⇒ THE HEADER NAMES IT, because "Exactly ORBIT" needs no gloss at all. Several names share
+  // one table and no header can name one of them, so they keep the general form and each row's own
+  // forms line (already rendered, unchanged) carries that row's near-spellings.
+  const single = marks.length === 1 ? String(marks[0]?.name ?? '').trim() : '';
+  const forms = single
+    ? ((countsForMark(registerCounts, single)?.counts?.close?.forms ?? []).map((f) => String(f?.form ?? '').trim()).filter(Boolean))
+    : [];
+  const headLabel = (pk) => {
+    if (pk === 'identical') return single ? `Exactly ${single}` : 'Exactly the name';
+    if (pk === 'containing') return single ? `Contains ${single}` : 'Contains the name';
+    return forms.length ? `Near-spellings (${forms.join(', ')})` : 'Near-spellings';
+  };
+  const head = COUNT_PREDICATES.map((p) => `<th>${esc(headLabel(p.key))}</th>`).join('');
   const rows = marks.map((m) => {
     const e = countsForMark(registerCounts, m.name);
     const cells = COUNT_PREDICATES.map((p) => {
@@ -308,11 +451,13 @@ function countsSection(marks, registerCounts) {
     return `<tr><td><b>${esc(m.name)}</b><br><span class="ko-classes">${esc(scope)}</span></td>${cells}</tr>`
       + (forms ? `<tr class="ko-forms"><td colspan="${COUNT_PREDICATES.length + 1}">${esc(forms)}</td></tr>` : '');
   }).join('');
-  const provider = registerCounts.providerLabel ?? registerCounts.provider ?? 'the register';
-  const territories = (registerCounts.scope?.regions ?? []).join(', ') || 'worldwide';
+  // COUNT_BASIS IS OFF THE PAGE, NOT OUT OF THE RECORD (tracker issue 331 B). It is still written to
+  // report-data.json (knockoutReportData -> registerCountBasis) and still on the workbook, which is where
+  // 331 says it belongs; what it stops doing is printing twice on a page whose headers now say the same
+  // thing in three words each.
   return `<div class="panel">
   <div class="ko-counts ko-scroll"><table><thead><tr><th>Name</th>${head}</tr></thead><tbody>${rows}</tbody></table></div>
-  <p class="ko-basis">${esc(COUNT_BASIS)}<br>Counted on <b>${esc(provider)}</b> · territories: ${esc(territories)}.</p>
+  <p class="ko-basis">${esc(COUNTS_READER_LINE)}<br>${esc(territoriesLine(registerCounts))}</p>
 </div>`;
 }
 
@@ -514,6 +659,29 @@ function tierAbsenceLine(registerCounts, probeRan) {
 // A NAME is deliberately not emitted here for the control to send. `ref` is right there and reads
 // nicely, but portal-ui/src/contract/reportFrame.ts refuses a mark from the document side on purpose,
 // and the composite key IS a mark name. The server reads `ref` back off disk once it has resolved.
+/**
+ * THE CARD'S DETAIL, FOLDED (tracker issue 331 A.3).
+ *
+ * Visible on a card: the reference, the name, the band chip, the source chip, the one-sentence read and
+ * the evidence links. Folded: the paragraph that argues the band, and on a register card the use-check
+ * line and the record link with it.
+ *
+ * WHY A FOLD AND NOT A CUT. The paragraph is the reasoning, and 331 rejects "shortening by dropping the
+ * reasons" in as many words. It is one click away and it still prints — `ko-full` is on the element, so
+ * openAll() and the beforeprint handler both reach it and a saved PDF carries the whole argument.
+ *
+ * EMPTY IN, EMPTY OUT. A card with no detail renders no fold rather than an empty one, which is also the
+ * archived-run path: a run whose findings carry no `basis` renders exactly the card it was delivered.
+ */
+function whyBandFold(inner) {
+  const body = String(inner ?? '').trim();
+  if (!body) return '';
+  return `<details class="ko-full ko-why"><summary>${esc(WHY_BAND_LABEL)}</summary>${body}</details>`;
+}
+
+/** The card fold's own word. Stated once so the renderer and its tests read the same string. */
+const WHY_BAND_LABEL = 'Why this band';
+
 function findingBlock(v, framework, markIndex) {
   const meta = [v.type, v.owner].filter(Boolean).map((s) => esc(s)).join(' · ');
   const ev = v.evidence.map((u) => linkOrText(u)).join(' · ');
@@ -546,7 +714,7 @@ function findingBlock(v, framework, markIndex) {
             </div>
             ${meta ? `<p class="ko-findmeta">${meta}</p>` : ''}
             ${v.lead ? `<p class="ko-findnet">${inlineMd(v.lead)}</p>` : ''}
-            ${v.detail ? `<p class="ko-findbasis">${inlineMd(v.detail)}</p>` : ''}
+            ${whyBandFold(v.detail ? `<p class="ko-findbasis">${inlineMd(v.detail)}</p>` : '')}
             ${ev ? `<p class="ko-findev">Evidence: ${ev}</p>` : ''}
           </div>
         </div>
@@ -637,6 +805,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 +844,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) => {
@@ -670,18 +864,52 @@ function promotableRecords(entry, mark) {
 /** One sentence of what the filing IS, composed from the register's own fields. No adjective that the
  *  record did not supply, and every absent field says it is absent rather than rendering as a blank —
  *  a blank cell and an unstated field read alike to a human and only one is honest. */
+// ── THE OFFICE, NOT THE VENDOR (tracker issue 331 D) ────────────────────────────────────────────────
+//
+// The sentence read "A filing of the identical name on Clarivate Compumark — held by ..., status
+// PENDING, classes 9, 38, 45, territory us." Clarivate Compumark is the search vendor; the filing is at
+// the United States office. Naming the vendor in the position where a reader expects the register says
+// the filing exists somewhere it does not, and prints a raw two-letter territory code besides.
+//
+// The provider is still named — once, in scope, as the data source (territoriesLine), which is what it
+// is. A card states the office, the kind of right, its status, its owner and its classes.
+//
+// STATUS IS THE RECORD'S OWN WORD, lower-cased for the sentence and never re-classified: "pending" here
+// is the register's PENDING, not this renderer's reading of it. A record that states none says so.
+const REGISTRATION_WORDS = /^(?:reg|registered|registration)/i;
+
+/** "United States application (pending)" — the office and the kind of right, from the record's own fields. */
+function registerRightPhrase(r) {
+  const office = territoryName(r?.territory, { bare: true });
+  const status = String(r?.status ?? '').trim();
+  // A right whose status names a registration is a registration; anything else is an application. The
+  // record's raw word rides in the bracket either way, so the reader never has to trust the reading.
+  const kind = REGISTRATION_WORDS.test(status) ? 'registration' : 'application';
+  const where = office ? `${office} ` : '';
+  // The bracket exists to show the register's OWN word where that word adds something. On a record whose
+  // status already names the kind ("REGISTERED" beside "registration") it adds nothing but noise, so it
+  // is dropped — the reader has the same fact either way, in one word instead of two.
+  // "registration (registered)" and "application (application)" say the kind twice. Both roots are
+  // tested rather than stemmed, because a stemmer that turns "registered" and "registration" into one
+  // token also turns "pending" and "pended" into one, and "(pending)" is a fact the reader wants.
+  const echoes = (kind === 'registration' && REGISTRATION_WORDS.test(status))
+    || (kind === 'application' && /^(?:appl|filed?)/i.test(status));
+  const bracket = status && !echoes ? ` (${status.toLowerCase()})` : '';
+  return `${where}${kind}${bracket}`.trim();
+}
+
 function registerStatement(r, provider) {
-  const what = r.matchedBasis === 'close'
-    ? `A filing on ${provider} found under the close variation ${r.matchedForm ?? '—'}`
-    : `A filing of the identical name on ${provider}`;
+  const name = String(r?.mark ?? r?.name ?? '').trim();
   const classes = (Array.isArray(r.classes) ? r.classes : []).filter((n) => Number.isFinite(Number(n)));
-  const bits = [
-    r.owner ? `held by ${r.owner}` : 'proprietor not stated on the record',
-    r.status ? `status ${r.status}` : 'status not stated on the record',
-    classes.length ? `class${classes.length === 1 ? '' : 'es'} ${classes.join(', ')}` : 'classes not stated on the record',
-    r.territory ? `territory ${r.territory}` : null,
-  ].filter(Boolean);
-  return `${what} — ${bits.join(', ')}.`;
+  const lead = [name, registerRightPhrase(r)].filter(Boolean).join(', ');
+  const owner = r.owner ? `by ${r.owner}` : 'owner not stated on the record';
+  const cls = classes.length
+    ? `class${classes.length === 1 ? '' : 'es'} ${classes.join(', ')}`
+    : 'classes not stated on the record';
+  // A close-variation card says WHICH near-form matched, because the name at the head of the sentence is
+  // then not the name the client asked about and a reader must not have to guess which it is.
+  const via = r.matchedBasis === 'close' && r.matchedForm ? ` Found under the close variation ${r.matchedForm}.` : '';
+  return `${lead} ${owner}, ${cls}.${via}`;
 }
 
 /**
@@ -697,6 +925,72 @@ function registerStatement(r, provider) {
  * form would point a reader at a row that does not exist. Its receipt is the register record itself,
  * which the card links.
  */
+/**
+ * WHICH OF A MARK'S REGISTER CARDS THE PAGE DRAWS (tracker issue 331 A.3).
+ *
+ * THIS FILTERS THE PAGE, NEVER THE RECORD, and that separation is the whole point. 331 rejects dropping
+ * anything from report-data.json or the workbook to make the page shorter, so `registerCardViews` still
+ * builds every promoted filing and still assigns the ordinals it always did — knockoutReportData reads
+ * that, unchanged. This function decides only what is DRAWN.
+ *
+ * Keeping one projection also keeps the flag path honest: portal-service resolves a flag as
+ * `marks[i].findings.find(f => f.ordinal === ordinal)`, so a card on the page carries the ordinal its
+ * own data entry has. A card the page does not draw cannot be flagged, because there is nothing to click.
+ *
+ * ONLY AN EXPLICIT LOWEST-RUNG BAND SUPPRESSES A CARD. Absence never does, and that is the whole rule —
+ * there is no second condition and no archived-run special case, because this one covers both.
+ *
+ * The first cut read an absent band as "lowest" and needed a clause-F escape hatch beside it: if no
+ * filing on the mark carried a band, keep them all. That escape hatch is what a wrong default looks
+ * like. It handled the run with NO bands and silently mishandled the run with SOME: `band` is optional
+ * per row, so a rater who bands the filings that matter and leaves the rest alone is doing what the
+ * shape invites — and the mark whose one typed band happened to be the bottom rung lost every card it
+ * had, including the filings nobody ruled on.
+ *
+ * `atLowestBand` below already argues this, one function down: a band it cannot place on the ladder
+ * is kept, because "the rater said something, and the safe reading of something we cannot rank is that
+ * it is worth pointing at". An absent band is strictly LESS information than an unrankable one, so if
+ * unknown keeps, absent keeps. Dropping it would be this renderer deciding a filing is immaterial on
+ * the rater's behalf — the same claim tracker issue 274 removed from these cards for the same reason.
+ *
+ * A run that carries no bands at all still renders every card it was delivered with, which is what
+ * clause F asks for; it now falls out of the rule instead of being carved around it.
+ */
+function registerCardsOnPage(cards, mark, framework) {
+  return cards.filter((v) => !atLowestBand(framework, readBandFor(mark, v?.record?.recordId)));
+}
+
+/**
+ * DID THE RATER PUT THIS FILING ON THE LADDER'S LOWEST RUNG? (tracker issue 331 A.3)
+ *
+ * The ladder runs worst-first, so the lowest rung is the LAST entry. A filing the rater put there is one
+ * the rater called manageable, and 331 keeps those in the filings table rather than on a card: three
+ * cards whose own text says the filing does not bear materially on the rating cost the reader more than
+ * they told him.
+ *
+ * Stated as "is it AT the lowest rung" rather than "is it above it", because that is the only direction
+ * a caller may act on. Every other answer — a rung higher up, a word this build cannot place on the
+ * run's own ladder, no band at all — is a filing that keeps its card. An unplaceable word is not a band
+ * this function may quietly demote: the rater said something, and the safe reading of something we
+ * cannot rank is that it is worth pointing at. Absence says even less, so it keeps the card too.
+ */
+function atLowestBand(framework, band) {
+  const ladder = Array.isArray(framework?.bands) ? framework.bands : [];
+  const word = String(band ?? '').trim().toLowerCase();
+  if (!word || !ladder.length) return false;
+  const lowest = String(ladder[ladder.length - 1]?.label ?? '').trim().toLowerCase();
+  return Boolean(lowest) && word === lowest;
+}
+
+/** The rater's band for one filing, off the row that names it. `null` when the rater gave none. */
+function readBandFor(mark, recordId) {
+  const id = String(recordId ?? '').trim();
+  if (!id) return null;
+  const row = (Array.isArray(mark?.registerReads) ? mark.registerReads : [])
+    .find((x) => String(x?.recordId ?? '').trim() === id);
+  return String(row?.band ?? '').trim() || null;
+}
+
 function registerCardViews(mark, framework, registerRecords) {
   if (!registerRecords || registerRecords.unavailable) return { cards: [], entry: null, promoted: 0 };
   const entry = recordsForMark(registerRecords, mark?.name);
@@ -728,9 +1022,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 +1057,117 @@ 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 = 'Purple notes are for the reviewing lawyer. Remove them before this goes to the client.';
+
+// 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;
+}
+
+// The two-place sort lives in findings-model.mjs (splitKnockoutNotes) because the predelivery lint
+// needs the same answer: the page files each note, and the reviewer warns a writer whose note will file
+// the way they did not intend. One reader, so the two can never disagree.
+/**
+ * "About this request" — what was asked, and any flag on the asking (tracker issue 331 A.1).
+ *
+ * WHAT WAS ASKED IS CODE-OWNED. It is read off the run's own frozen instructed scope, never off model
+ * prose, so the line states the request the run was given rather than a paraphrase of it. An archived run
+ * that carries no such sidecar renders the flags alone, and a run with neither renders nothing at all —
+ * the block never appears empty and never appears with a heading over nothing.
+ *
+ * THE FLAGS ARE THE REVIEWER'S OWN WORDS, unedited. This surface moves them; it does not rewrite them.
+ * They keep the purple convention here exactly as they wear it under the cards, which is also what keeps
+ * them off the export: the strip is one rule on .internal and it reaches both places.
+ */
+function aboutRequestBlock(scope, requestNotes) {
+  const goods = String(scope?.goods ?? '').trim();
+  const classes = (Array.isArray(scope?.classes) ? scope.classes : []).filter((c) => c || c === 0);
+  const jx = (Array.isArray(scope?.jurisdictions) ? scope.jurisdictions : []).map((t) => territoryName(t)).filter(Boolean);
+  const asked = [
+    classes.length ? `Class${classes.length === 1 ? '' : 'es'} ${classes.join(', ')}` : '',
+    goods,
+  ].filter(Boolean).join(' — ');
+  const where = jx.length ? `Searched in ${listWords(jx)}.` : '';
+  const flags = (requestNotes ?? []).filter(Boolean);
+  if (!asked && !where && !flags.length) return '';
+  return `<div class="ko-req">
+      <span class="ko-lbl2">About this request</span>
+      ${asked ? `<p>${esc(asked)}</p>` : ''}
+      ${where ? `<p>${esc(where)}</p>` : ''}
+      ${flags.length ? `<div class="internal ko-reqflag">${
+        flags.map((n) => `<p class="ko-bul">${inlineMd(n)}</p>`).join('')}</div>` : ''}
+    </div>`;
+}
+
+function reviewerNotesBlock(m) {
+  const notes = splitKnockoutNotes(m).name;
+  if (!notes.length) return '';
+  return `<div class="internal">
+            <span class="tag">For the reviewing lawyer</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>
@@ -900,34 +1287,117 @@ function coverageClause(mark, registerCounts, probeRan) {
 // NOTHING IS DISCARDED. Where a run carries both the typed fields and prose bullets the bullets survive
 // under a collapsed "Full narrative" — the reader who wants the long form still has it, one click away,
 // and no sentence the stage wrote is dropped on the floor.
-function readBlock(m) {
+/**
+ * THE LABELS, IN THE READER'S WORDS (tracker issue 331 A.2).
+ *
+ * The old pair was "What holds it there" and "What would move it", 9.5px grey capitals. The owner read
+ * the first one and asked "what holds what?" — so the fix is not a synonym in the same style, it is a
+ * label that carries the band's own word and answers the question by itself.
+ *
+ *   factors        → "Why High"              (the mark's own band)
+ *   counterFactors → "Why not Very High"     (the rung ABOVE it on the run's own ladder)
+ *   mitigation     → "What would lower the risk"
+ *
+ * The ladder runs worst-first, so the rung above is the PREVIOUS entry. At the top rung there is no
+ * higher band to name and the honest label is "What keeps it here" — the same question, asked where the
+ * comparative form has no answer. A band this build cannot find on the ladder gets that label too,
+ * rather than a comparative naming a rung that may not exist.
+ */
+function counterLabel(framework, band) {
+  const ladder = Array.isArray(framework?.bands) ? framework.bands : [];
+  const i = ladder.findIndex((b) => String(b?.label ?? '').trim().toLowerCase() === String(band ?? '').trim().toLowerCase());
+  const up = i > 0 ? String(ladder[i - 1]?.label ?? '').trim() : '';
+  return up ? `Why not ${up}` : 'What keeps it here';
+}
+
+const ASSESSMENT_FOLD_LABEL = 'Read the full assessment';
+
+/** The scope block's own words, as one string, so the caveat filter reads exactly what the page prints. */
+const SCOPE_BLOCK_TEXT = 'What this is. A fast screen for obvious blockers to using each name, from '
+  + 'marketplace and web use plus a count of register filings. What it is not. A clearance search. We '
+  + 'drew no register conclusions and give no filing advice. A name that passes here is not clear; it '
+  + 'goes on to clearance. Every conflict above links to the material we found. The audit workbook holds '
+  + 'every search run, every empty result and the working notes. Register data.';
+
+/** Words that carry no claim, so their presence or absence says nothing about what a sentence asserts. */
+const STOPWORDS = new Set(['a', 'an', 'and', 'are', 'as', 'at', 'be', 'been', 'but', 'by', 'can', 'do',
+  'does', 'each', 'for', 'from', 'has', 'have', 'here', 'in', 'is', 'it', 'its', 'no', 'not', 'of', 'on',
+  'or', 'that', 'the', 'their', 'them', 'there', 'these', 'they', 'this', 'to', 'up', 'was', 'we', 'were',
+  'what', 'when', 'which', 'will', 'with', 'you', 'your']);
+
+const contentWords = (s) => String(s ?? '').toLowerCase().replace(/[^a-z0-9\s-]/g, ' ')
+  .split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+
+/**
+ * Does this line assert anything the reference text does not already assert?
+ *
+ * TRUE unless every content word in the line is already in the reference. An empty line has nothing to
+ * say and returns false; a line with one unfamiliar word is kept. Singular/plural is folded so that
+ * "conclusion" does not read as new beside "conclusions".
+ */
+function saysSomethingNew(line, reference) {
+  // The stem must be IDEMPOTENT on the singular, or the fold does nothing: an earlier form stripped
+  // "es" and turned "gives" into "giv" while leaving "give" alone, so the two never matched and every
+  // caveat looked new. Strip one trailing "s" and nothing else.
+  const stem = (w) => w.replace(/ies$/, 'y').replace(/s$/, '');
+  const known = new Set(contentWords(reference).map(stem));
+  const words = contentWords(line);
+  if (!words.length) return false;
+  return words.some((w) => !known.has(stem(w)));
+}
+
+function readBlock(m, framework) {
   const factors = (m.factors ?? []).filter((s) => typeof s === 'string' && s.trim());
   const counter = (m.counterFactors ?? []).filter((s) => typeof s === 'string' && s.trim());
   const structured = Boolean(m.basis || factors.length || counter.length || m.mitigation);
   const bullets = (m.bullets ?? []).map((b) => `<li>${inlineMd(b)}</li>`).join('');
   if (!structured) return bullets ? `<ul class="ko-bul">${bullets}</ul>` : '';
+  const assessment = String(m.assessment ?? '').trim();
+  const band = String(m.rating ?? '').trim();
   return [
     m.basis ? `<p class="ko-basisline">${inlineMd(m.basis)}</p>` : '',
-    factors.length ? `<ul class="ko-bul">${factors.map((f) => `<li>${inlineMd(f)}</li>`).join('')}</ul>` : '',
-    counter.length ? `<div class="ko-counter"><span class="ko-lbl">What holds it there</span><ul class="ko-bul">${
+    factors.length ? `<div class="ko-why-band">${band ? `<span class="ko-lbl2">Why ${esc(band)}</span>` : ''}<ul class="ko-bul">${
+      factors.map((f) => `<li>${inlineMd(f)}</li>`).join('')}</ul></div>` : '',
+    counter.length ? `<div class="ko-counter"><span class="ko-lbl2">${esc(counterLabel(framework, band))}</span><ul class="ko-bul">${
       counter.map((f) => `<li>${inlineMd(f)}</li>`).join('')}</ul></div>` : '',
-    m.mitigation ? `<div class="ko-mitig"><span class="ko-lbl">What would move it</span><p>${inlineMd(m.mitigation)}</p></div>` : '',
-    bullets ? `<details class="ko-full"><summary>Full narrative</summary><ul class="ko-bul">${bullets}</ul></details>` : '',
+    m.mitigation ? `<div class="ko-mitig"><span class="ko-lbl2">What would lower the risk</span><p>${inlineMd(m.mitigation)}</p></div>` : '',
+    // ── THE ASSESSMENT REPLACES THE "FULL NARRATIVE" FOLD (tracker issue 331 A.2) ────────────────────
+    //
+    // The model writes both. `bullets` (five) say in other words what `factors` (four) already say
+    // visible above; `assessment` is the long-form read under its own four headings, and until now the
+    // page rendered it NOWHERE — validated, carried in report-data.json and the workbook, never shown.
+    // The owner found the bullets fold by accident and called it the most useful block on the page; the
+    // assessment is the better version of the same thing.
+    //
+    // `bullets` is NOT dropped from the record — knockoutReportData still carries it and the workbook
+    // still writes it. What retires is one fold on one page, replaced by a longer answer to the same
+    // question. 331 rejects dropping the field itself, and this does not.
+    //
+    // CLAUSE F. An archived run carries bullets and no assessment: it keeps the fold it was delivered
+    // with, under its own old label. The fallback is the old block, never an empty new one.
+    assessment
+      ? `<details class="ko-full"><summary>${esc(ASSESSMENT_FOLD_LABEL)}</summary><div class="ko-assess">${mdParagraphs(assessment)}</div></details>`
+      : (bullets ? `<details class="ko-full"><summary>Full narrative</summary><ul class="ko-bul">${bullets}</ul></details>` : ''),
   ].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);
+    const bullets = readBlock(m, framework);
     // — the promoted register filings, in the SAME list as the common-law conflicts. They render
     // after the typed findings and that position is not a rank: a card with no band already sorts last
     // 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 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>`
+    const drawn = registerCardsOnPage(reg.cards, m, framework);
+    const regBlocks = drawn.map((v) => registerFindingBlock(v, markIndex, m?.registerReads, framework, ownerChecks)).join('');
+    // The overflow counts what is NOT on the page against what met the promotion test — cards held back
+    // by the cap and cards the rater put on the lowest rung alike, because from the reader's side they
+    // are the same fact: further filings for this name, all of them listed below.
+    const held = reg.promoted - drawn.length;
+    const overflow = held > 0
+      ? `<p class="ko-bul">${esc(`${held} further filing${held === 1 ? '' : 's'} for this name met the same test — every one of them is in the filings section below.`)}</p>`
       : '';
     // THE DEFECT THIS CLOSES. This line was `(m.findings ??).filter((f) => f?.url)`, and a
     // typed finding has no `url` — so every conflict was dropped from the page and a mark whose findings
@@ -950,11 +1420,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
@@ -1012,87 +1488,6 @@ function depthStrip(note) {
 // says what the lines under it are. It is not a filter and it rewrites no caveat.
 const CAVEAT_LEAD = 'This screen also carries the following limits:';
 
-/**
- * WHAT THIS RUN SEARCHED AND DID NOT, FROM THE RUN'S OWN POLICY.
- *
- * The line this replaces was composed from `registerCounts` — an ARTIFACT — and said "Common-law/
- * marketplace screen only, register searches are addressed separately" whenever no counts were present.
- * That reads the absence of a result as a statement of scope, which is the class this repo keeps paying
- * for: a run INSTRUCTED to take register counts whose provider refused printed the same sentence as a
- * run never instructed to take them at all. One of those is a scope statement and the other is a gap in
- * the record, and a client cannot tell them apart.
- *
- * The clearance report composes its scope from the run's frozen components (`productCoverageNote`,
- * search-policy.mjs) and this now does the same, from the same object, so the two lanes cannot describe
- * the same component in different words.
- *
- * THE ARTIFACT IS STILL REPORTED — separately, and as what it is. Where the policy says a component ran
- * and its output is missing, that is disclosed as a gap rather than folded into "we did not do it".
- *
- * @returns {string[]} lines, most load-bearing first. Empty when there is no policy to read, and the
- *          caller falls back to the artifact-derived sentence rather than printing nothing.
- */
-export function knockoutScopeLines(policy, { registerCounts = null, probeRan = false } = {}) {
-  const c = policy?.components;
-  if (!c) return [];
-  const lines = [];
-  lines.push('This is a screen, not a clearance search: it triages names against use we can see, '
-    + 'and makes no filing recommendation.');
-  if (c.registerProbe) {
-    const who = registerCounts?.providerLabel ?? registerCounts?.provider ?? null;
-    // THE BASIS RIDES WITH THE COMPONENT THAT NEEDS IT, in methodLine's own words rather than new ones.
-    // Composing this section from the policy moved methodLine off the page for every run that HAS a
-    // policy — which is every live run — and took COUNT_BASIS and "Counting is not searching" with it.
-    // That is the sentence saying a count weighs nothing and decides nothing, on the page that prints
-    // the counts. `runner.knockout-e2e.test.mjs` caught it and this branch called it pre-existing;
-    // it is not — origin/main's renderer passes that arm 3/3 in the same worktree.
-    lines.push(registerCounts
-      ? `Registers were searched for a hit-count per name${who ? ` on ${who}` : ''}, and the filings behind `
-        + `the narrow counts are listed below. ${COUNT_BASIS} Counting is not searching: no register `
-        + `conclusions, no filing advice, and a full register clearance is a separate piece of work.`
-      : 'Registers were searched for a hit-count per name, and no counts reached this report — '
-        + 'that is a gap in the record for this run, not a statement that registers were left out.');
-  } else if (c.registerProbe === false) {
-    lines.push(probeRan
-      ? 'Registers were not part of this search. A register count screen ran separately; full register analysis is its own piece of work.'
-      : 'Registers were not searched in this search.');
-  }
-  // A COMPONENT THE POLICY DOES NOT MENTION IS NOT A COMPONENT THAT WAS OFF. Same rule as the missing
-  // policy above, one level down: `undefined` is silence, and silence is not `false`. Reached only when
-  // `components` arrives without this key — every row in search-policy.mjs states all three, so the
-  // product table cannot produce it; `{ ...policyFor(product)?.components, ...r.components }` can, when
-  // the product resolves to nothing. Driven before this line existed: an empty `components` printed
-  // "Registers were not searched in this search" on a report that was carrying a register hit-count
-  // table, which is the document contradicting itself in the section that exists to state scope. Saying
-  // nothing is the honest answer, and it needs no new sentence in front of a client.
-  //
-  // THE TWO BELOW STAY `!== true`, and the difference is the population rather than the principle.
-  // `registerProbe` is true on two knockout rows (knockout-search, knockout-register), so silence about
-  // it is genuinely ambiguous. `commonLawGrid` and `jxLanes` are false on EVERY row this template
-  // renders — they are what the clearance search is — so silence there states a thing that is true of
-  // the whole population, and making them conditional would drop a disclosure the clearance report
-  // makes about itself. Symmetry here would cost a client the sentence naming the lane they did not buy.
-  // Stated because the clearance report states its own absence of them, in these words. A reader
-  // comparing two documents must not have to infer that a lane is missing from its silence.
-  if (c.commonLawGrid !== true) {
-    lines.push('The systematic common-law grid sweep is not part of this search — that is the clearance search.');
-  }
-  if (c.jxLanes !== true) {
-    lines.push('The per-jurisdiction native-script deep dive is not part of this search.');
-  }
-  return lines;
-}
-
-function methodLine(registerCounts, probeRan, { citedFindings = 0, uncitedFindings = 0 } = {}) {
-  const receipts = (citedFindings && !uncitedFindings)
-    ? ` Every conflict named above cites material held in this run's own research payload for that name.`
-    : '';
-  return (registerCounts
-    ? `Common-law/marketplace screen, plus a register HIT-COUNT per name on ${registerCounts.providerLabel ?? registerCounts.provider ?? 'the register'}. ${COUNT_BASIS} `
-      + `Counting is not searching: no register conclusions, no filing advice, and a full register clearance is a separate piece of work.`
-    : `Common-law/marketplace screen only — register searches are addressed separately${probeRan ? ' (a register count screen ran; full register analysis follows separately)' : ''}. `
-      + `A knockout screen is triage, not a clearance search: no register conclusions, no filing advice.`) + receipts;
-}
 
 /**
  * Render the knockout report.
@@ -1114,11 +1509,20 @@ 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
   // run that carries none keeps the artifact-derived sentence it was delivered with.
   searchPolicy = null,
+  // — the run's own frozen instructed scope (tracker issue 331 A.1): the goods, classes and
+  // territories the requester asked for, in the requester's words. Defaults to null, and an archived run
+  // that carries no such sidecar renders "About this request" from its request-level notes alone, or not
+  // at all when it has none. Never derived from model prose — this is what was ASKED, not what was said
+  // about it.
+  instructedScope = null,
   // — the run's frozen delivery overlay. It defaults to null, which is the NO-OPINION state and
   // renders the same plain "Privileged & Confidential" this template always printed — so the ~15 unit
   // fixtures and both render-check scripts, none of which pass one, are unchanged by its arrival.
@@ -1145,7 +1549,12 @@ export function renderKnockoutHtml(findings, framework, {
   const allViews = marks.flatMap((m) => knockoutFindingViews(m, { manifest: framework }));
   const citedFindings = allViews.filter((v) => v.evidence.length).length;
   const uncitedFindings = allViews.length - citedFindings;
-  const glance = glanceSection(marks, framework, registerCounts);
+  // ── A ONE-NAME PAGE HAS NO INDEX (tracker issue 331 A.6) ────────────────────────────────────────
+  //
+  // The glance row exists to let a reader of a BATCH find the name they care about. With one name there
+  // is nothing to index, and the row printed that name, its band and its classes for the first of three
+  // times before the reader reached a single sentence of reading. On a batch it stays exactly as it was.
+  const glance = marks.length > 1 ? glanceSection(marks, framework, registerCounts) : '';
   const hasCounts = Boolean(registerCounts?.marks?.length);
   // The register block is a table when counts were taken and a SENTENCE when they were not — never
   // nothing. It renders in the place the numbers would have occupied, at the top of the section that
@@ -1154,7 +1563,24 @@ 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 });
+  // ── A CAVEAT THAT SAYS NOTHING THE SCOPE BLOCK HAS NOT SAID IS NOT RENDERED (tracker issue 331 E) ──
+  //
+  // The four model-written caveats on the measured run overlap the fixed text completely — 331 item 9,
+  // and 333 rule 4 ("say it once") fixes it at the source for runs written under that doctrine. This is
+  // the reader for the ones already written.
+  //
+  // THE TEST IS SUBSET, NOT SIMILARITY, and the difference is the whole safety argument. A caveat is
+  // dropped only when EVERY content word in it already appears in the scope block. A caveat making any
+  // new claim brings at least one new content word with it and is kept — so this cannot silently delete
+  // a disclosure, which is the one failure that would matter on a client-facing page. A similarity score
+  // could; that is why there isn't one.
+  const newCaveats = caveats.filter((c) => saysSomethingNew(c, SCOPE_BLOCK_TEXT));
+  const analysis = analysisSection(marks, framework, { registerCounts, probeRan, registerRecords, ownerChecks });
+  // The request-level notes, gathered across every mark on the document and rendered ONCE at the top.
+  // They are about the asking, not about a name, so a batch repeating them per mark would be the same
+  // sentence three times. reviewerNotesBlock renders the rest, under that mark's own cards.
+  const requestNotes = marks.flatMap((m) => splitKnockoutNotes(m).request);
+  const aboutRequest = aboutRequestBlock(instructedScope, requestNotes);
   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.
@@ -1165,7 +1591,10 @@ export function renderKnockoutHtml(findings, framework, {
   // promoted filing that sentence sent a reader to a row that does not exist. A false pointer on the
   // audit trail is worse than no pointer, and the honest fix is to narrow the claim rather than mint a
   // second drill-through key for a card whose receipt is the register record itself.
-  const registerCardCount = marks.reduce((n, m) => n + registerCardViews(m, framework, registerRecords).cards.length, 0);
+  // Counted over what the page DRAWS: the sentence explains a REG reference a reader can see, so a run
+  // whose register cards are all held back needs no sentence about them.
+  const registerCardCount = marks.reduce((n, m) =>
+    n + registerCardsOnPage(registerCardViews(m, framework, registerRecords).cards, m, framework).length, 0);
   const hasRecords = Boolean(registerRecords && (registerRecords.marks?.length || registerRecords.unavailable));
   const filings = hasRecords ? filingsSection(marks, registerRecords) : '';
   const onFieldSec = `<div class="sec"><span class="num">${num()}</span><h2>On-field conflicts</h2><span class="note">${hasCounts ? `register hit-counts (${esc(provider)}) and the read, per name` : 'what we found, per name'}</span></div>
@@ -1226,6 +1655,7 @@ window.addEventListener('beforeprint',o);})();</script>
     ${depthStrip(depthNote)}
     <h1 class="mark">${esc(title)}</h1>
     ${productContext ? `<p class="ko-classes" style="font-size:13.5px;margin:0 0 16px">${inlineMd(productContext)}</p>` : ''}
+    ${aboutRequest}
     ${summary ? `<div class="sub">${mdParagraphs(summary)}</div>` : ''}
   </header>
 
@@ -1247,14 +1677,31 @@ window.addEventListener('beforeprint',o);})();</script>
       // FROM THE POLICY WHERE THERE IS ONE (tracker issue 1935). The fallback is not a tidy default: an
       // archived run froze no policy, and re-rendering it must not invent a scope claim about a run
       // nobody can now ask. It keeps the sentence it was delivered with.
-      const lines = knockoutScopeLines(searchPolicy, { registerCounts, probeRan });
-      if (!lines.length) return `<p class="ko-scope">${esc(methodLine(registerCounts, probeRan, { citedFindings, uncitedFindings }))}</p>`;
-      const receipts = citedFindings && !uncitedFindings
-        ? '<p class="ko-scope">Every conflict named above cites material held in this run\'s own research payload for that name.</p>'
+      // ── THE SCOPE BLOCK, WHOLE (tracker issue 331 E) ──────────────────────────────────────────────
+      //
+      // The composed lines said one thing five times in 362 words: "not a clearance" three times,
+      // "proceeds to clearance" twice, and the count-basis sentence a second time after the counts table
+      // had already carried it. This is the owner's replacement text, and its two halves are the two
+      // questions a reader of a screen actually has.
+      //
+      // "Every conflict above links to the material we found" STAYS CONDITIONAL and that is not a
+      // stylistic carry-over: said unconditionally it is an absence claim wider than what was examined,
+      // which this file refuses elsewhere in the same words. It prints only when every rendered conflict
+      // cites something.
+      const linked = citedFindings && !uncitedFindings
+        ? ' Every conflict above links to the material we found.'
+        : '';
+      const source = registerCounts
+        ? ` Register data: ${registerCounts.providerLabel ?? registerCounts.provider ?? 'the register'}.`
         : '';
-      return `${lines.map((l) => `<p class="ko-scope">${esc(l)}</p>`).join('')}${receipts}`;
+      return `<p class="ko-scope"><b>What this is.</b> A fast screen for obvious blockers to using each `
+        + `name, from marketplace and web use plus a count of register filings.</p>`
+        + `<p class="ko-scope"><b>What it is not.</b> A clearance search. We drew no register conclusions `
+        + `and give no filing advice. A name that passes here is not clear; it goes on to clearance.</p>`
+        + `<p class="ko-scope">${linked.trim()}${linked ? ' ' : ''}The audit workbook holds every search run, `
+        + `every empty result and the working notes.${source}</p>`;
     })()}
-    ${caveats.length ? `<p class="ko-scope" style="border-top:1px solid var(--line)">${CAVEAT_LEAD}<br>${caveats.map((c) => inlineMd(c)).join('<br>')}</p>` : ''}
+    ${newCaveats.length ? `<p class="ko-scope" style="border-top:1px solid var(--line)">${CAVEAT_LEAD}<br>${newCaveats.map((c) => inlineMd(c)).join('<br>')}</p>` : ''}
     ${auditFile ? `<p class="ko-scope" style="border-top:1px solid var(--line)"><a href="${escAttr(auditFile)}">Download the audit workbook (Excel)</a> — every search run, every negative result, and the working notes behind these ratings.${
     citedFindings ? ` The reference beside each common-law conflict above (for example <span class="mono">${esc(firstRef(marks, framework))}</span>) is its row on the workbook's Findings sheet.${
       registerCardCount ? ` A <span class="mono">REG</span> reference is a register filing rather than a common-law conflict — it has no Findings row, and its receipt is the register record the card links.` : ''}` : ''}</p>` : ''}
@@ -1282,7 +1729,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 +1771,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 +1825,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
           ? {