clearotron 0.3.2-beta.7 → 0.3.2-beta.9

package/driver/publish/render.mjs

@@ -25,13 +25,14 @@ import { fileURLToPath } from 'node:url';
 // its own split, which is how the two rules diverged. It calls stripTelemetry now, so the renderer holds
 // no copy of the RULE either, only a call to it.
 import { parseReport, stripInternal, stripTelemetry } from './parse.mjs';
-import { clientConditions } from '../terminal-clamp.mjs';   // the reader's clause per condition, shared with the cover note
+import { clientConditions } from '../terminal-clamp.mjs';
+import { EXPORT_TOGGLE, exportPopover, EXPORT_MENU_JS } from './report-topbar.mjs';   // the export menu's shell and behaviour, shared with the knockout template   // the reader's clause per condition, shared with the cover note
 import { COMMON_LAW, normRegion, regionName, REGION_NAMES } from './regions.mjs';
 import { parseFindingsJson, bindRecommendation, sentenceCaseLead, CLIENT_TIER_BY_COMPOSITE, bandOf, compareBlockingPower, inDispositionMode, reasonedNegativeGroups } from '../findings-model.mjs';
 import { REC, inPriorityWindow, ownerDisplayName } from '../registry-fidelity.mjs';
 import { registrationSystem } from '../jurisdiction-systems.mjs';
 import { READ_LEAD_RE } from '../report-card-record.mjs';   // D3 — the dedupe gate and the card's acceptance are ONE predicate
-import { REPORT_ROOT, REPORT_ROOT_DARK_EXPLICIT, THEME_INIT_EXPLICIT, FAVICON_LINK, logoLockup, BRAND, confPosture } from '../../shared/brand.mjs';
+import { REPORT_ROOT, REPORT_ROOT_DARK_EXPLICIT, THEME_INIT_EXPLICIT, FAVICON_LINK, logoLockup, BRAND, confPosture, sectionStrip } from '../../shared/brand.mjs';
 import { NAV_CSS } from '../../shared/site-nav.mjs';
 import { isEntrypoint } from "../../shared/is-entrypoint.mjs";   // — realpath both sides, or a symlinked invocation exits 0 silently
 
@@ -59,6 +60,16 @@ let SEARCHED_JUR = null;
 let SCOPE_WORLDWIDE = null;
 // T7 — the two deterministic evidence joins (set per render from opts):
 let CASE_LAW_BY_ORD = new Map();   // E5: ordinal → grounded case-law profile
+// Whether the case-law pass found anything: 'found' | 'none-found' | 'not-checked' | null.
+// The CARD strand is suppressed on the two states that mean there is no precedent to cite, because the
+// profile body is then the engine's account of WHY — adapter names, session error codes, which sources
+// were out of scope — a true sentence about the machinery and not the client's answer, and the Court
+// decisions section states that outcome in the reader's own words already.
+//
+// NULL IS NOT ONE OF THEM. A report with no court state carries no Court decisions section either (it
+// is full-country only), so suppressing there would take case-law off the page with nothing left
+// saying so. Absence of a state is not a statement that nothing was found.
+let COURT_DECISIONS = null;
 let ENFORCER_SIGNALS = new Map();  // E6: registration uri (lowercase) → {aggression, oppositions, owner}
 // WP-receipts W2 — per-render provider record-link origin + label, resolved by publish from the run's
 // OWN _driver/receipts.json provider (never the currently-configured provider — a re-published archive
@@ -143,11 +154,19 @@ function frameworkTickIndex(findings) {
 // verdict with EVERY condition, "Why <band>" as the four answers with the basis each rests on, the
 // highest exposure, and what was searched to get there. Nothing here is composed — the conditions are
 // the sidecar's own client-voice clauses, the answers are the engine's, and the coverage line is counts.
-function ratingExtras(fm, findings, coverage, fourAnswers, opts, bandWord) {
+function ratingExtras(fm, findings, coverage, fourAnswers, opts, bandWord, conditionsInVerdict = false) {
   const out = [];
-  const conds = clientConditions(VERDICT_INFO || {});
-  if (conds.length) out.push(`<div class="gconds-wrap"><span class="gk">Conditions</span><ul class="gconds">${
-    conds.map((c) => `<li>${esc(c)}</li>`).join('')}</ul></div>`);
+  // THE CONDITIONS HAVE ONE HOME PER PATH, AND IT IS NEVER NONE. Where the verdict row could take
+  // them — a sidecar whose composed statement carries the "conditional on:" lede — they render there,
+  // inside the verdict, which is where the mock puts them and where they read as the terms the verdict
+  // is conditional on rather than a list beside it. Where it could not, this row renders exactly as it
+  // did: the legacy gauge has no lede to hang them from, and dropping the row there would hide every
+  // condition on precisely the archived runs that cannot be re-rendered with better text.
+  if (!conditionsInVerdict) {
+    const conds = clientConditions(VERDICT_INFO || {});
+    if (conds.length) out.push(`<div class="gconds-wrap"><span class="gk">Conditions</span><ul class="gconds">${
+      conds.map((c) => `<li>${esc(c)}</li>`).join('')}</ul></div>`);
+  }
   const fa = fourAnswers && typeof fourAnswers === 'object' ? fourAnswers : null;
   if (fa) {
     const rows = FOUR_ANSWER_LABELS.map(([key, label], i) => {
@@ -240,8 +259,27 @@ function frameworkGauge(fm, findings, coverage = [], fourAnswers = null, opts =
       ? (bindRecommendation(fm.recommendation, VERDICT_INFO.verdict, []) || VERDICT_INFO.tier || '')
       : (fm.recommendation || fm.overall_label || '');
   const recLabel = VERDICT_INFO?.statement ? 'Verdict' : 'Recommendation';
+  // THE VERDICT CARRIES EVERY CONDITION, NOT THE FIRST AND A COUNT. The composed statement ends
+  // "(and N more)" because it is also a ONE-LINE surface — the email lede, the registry row — where a
+  // list cannot go. On the page there is room for all of them, and a condition a client is told exists
+  // but is not told is one they cannot act on. The lede is taken from the statement's OWN prefix rather
+  // than re-composed, so the tier wording stays the engine's and only the truncated tail is replaced;
+  // the clauses are the sidecar's client-voice ones, the same list the separate row used to carry.
+  // The legacy `gauge()` below keeps the composed line as it stands: an archived run with no framework
+  // sidecar renders byte-identically, which is the contract stated there.
+  // THE LIST RENDERS ON BOTH PATHS. A sidecar with a composed statement gets the lede and its
+  // conditions; a LEGACY one — reasons, no statement, no client-voice clause — has no lede to match, and
+  // dropping the list there would hide every condition on exactly the archived runs that cannot be
+  // re-rendered with better text. Those still render under the bound recommendation, which is where
+  // they were before this row moved.
+  const verdictConds = clientConditions(VERDICT_INFO || {});
+  const ledeMatch = typeof rec === 'string' ? rec.match(/^(.*?conditional on:)/i) : null;
+  const conditionsInVerdict = Boolean(ledeMatch && verdictConds.length);
+  const recHtml = conditionsInVerdict
+    ? `${esc(ledeMatch[1])}<ul class="gconds">${verdictConds.map((c) => `<li>${esc(c)}</li>`).join('')}</ul>`
+    : esc(rec);
   const conc = [
-    rec && `<div class="grow"><span class="gk">${recLabel}</span><span class="gv gv-rec">${esc(rec)}</span></div>`,
+    rec && `<div class="grow"><span class="gk">${recLabel}</span><span class="gv gv-rec">${recHtml}</span></div>`,
   ].filter(Boolean).join('');
   // — THE FRAMEWORK IS NAMED WHERE ITS WORDS ARE READ, not only in the footer. `.ticks` below spells
   // a vocabulary ("Manageable", "Moderate") that is meaningless without the framework in force, and the
@@ -255,7 +293,7 @@ function frameworkGauge(fm, findings, coverage = [], fourAnswers = null, opts =
     <div class="scale" style="background:${grad}">${marker}</div>
     <div class="ticks">${ticks}</div>
     <div class="gconc">${conc}</div>
-    ${ratingExtras(fm, findings, coverage, fourAnswers, opts, label)}
+    ${ratingExtras(fm, findings, coverage, fourAnswers, opts, label, conditionsInVerdict)}
   </div>`;
 }
 
@@ -514,7 +552,6 @@ const useEvidence = (m) => [USE_EVIDENCE_LABEL[m?._status], USE_SOURCE_LABEL[m?.
 // runs carry the old value forever and a fourth spelling of it would have to be accepted everywhere.
 const USE_CHECK_NO_RESULT = 'perplexity_research — no result';
 const USE_CHECK_NO_RESULT_CITE = 'Nothing found in the marketplaces searched.';
-const USE_CHECK_NO_RESULT_SHORT = 'marketplace search — no result found';
 // — MATCHED ON NORMALISED PUNCTUATION, NOT ONE SPELLING. The constant itself does not
 // move (archived runs carry it forever, the validators name it), but the SEAT emitted a hyphen where
 // the doctrine writes an em dash, and exact equality let the raw tool name through to a delivered
@@ -963,8 +1000,13 @@ function clearedGroupsHtml(searchDepth, auditFile) {
     const items = reg.filter((c) => c.group === g);
     if (!items.length) return '';
     const shown = items.slice(0, NAMES_CAP);
+    // "Cl." and a lower-case status, which is how the mock reads and how a lawyer writes it. The
+    // register hands the status back in capitals — REGISTERED, CANCELLED — and shouting a neutral
+    // fact at a reader is the register's habit, not ours. Only the case changes; the word is the
+    // register's own and is not translated.
     const rows = shown.map((c) => `<div class="crow"><span class="cm-mark">${esc(c.mark || c.term || '')}</span><span class="cwho">${
-      esc([c.owner, regionName(c.country) || c.country, c.classes ? `Class ${c.classes}` : '', c.status].filter(Boolean).join(' \u00b7 '))}</span></div>`).join('');
+      esc([c.owner, regionName(c.country) || c.country, c.classes ? `Cl. ${c.classes}` : '',
+           c.status ? String(c.status).toLowerCase() : ''].filter(Boolean).join(' \u00b7 '))}</span></div>`).join('');
     return `<details class="cgroup"><summary><span class="gname">${esc(CLEARED_GROUP_LABEL[g] || g)}</span><span class="gcount">${
       items.length.toLocaleString('en-GB')} ${items.length === 1 ? 'name' : 'names'}</span></summary><div class="gbody">${rows}${
       items.length > shown.length ? link(items.length) : ''}</div></details>`;
@@ -999,26 +1041,70 @@ function whereItStandsSection(findings, opts) {
   const sd = opts && opts.searchDepth;
   if (!sd || !sd.counts || isFullCountry(opts)) return '';
   const byC = sd.counts.recordsByCountry || {};
-  const codes = Object.keys(byC).filter((c) => c !== 'WO');
-  if (!codes.length) return '';
   const bandBy = new Map();
   for (const f of findings) {
     const c = regionCode(f);
     if (!c || c === COMMON_LAW || !f.band) continue;
     if (!bandBy.has(c)) bandBy.set(c, f.band);
   }
+  // WHICH COUNTRIES THIS SECTION IS ABOUT COMES FROM THE SEARCH PLAN, NOT FROM THE RECORD ARCHIVE.
+  //
+  // The archive is the authority on what came back and was kept; the plan is the authority on what was
+  // asked of the register. Read off the archive, a provider that keeps no records produced no countries,
+  // no rows, no chips and no section at all — so a register nobody could archive read exactly like a
+  // register nobody searched, on the page a client acts on. Every provider that keeps partial records
+  // under-reported here for the same reason.
+  //
+  // `planTerritories` is three-valued and the third value is why this is not a one-line swap. `null`
+  // means there is no plan to read, which is every archived and legacy run: those keep the archive as
+  // their only authority and re-render exactly as they always have. A plan that named nothing is a
+  // different answer from no plan at all and is allowed to leave this section empty.
+  //
+  // THE FINDINGS' OWN COUNTRIES ARE UNIONED IN, never filtered out. A finding sitting in a territory the
+  // plan does not list — an international registration designating one, most often — had its row from
+  // the archive before this and must keep it: the section's first duty is that a country carrying a
+  // conflict is on the page.
+  //
+  // The plan's unreached territories are NOT drawn. This section has two slots in the approved board, a
+  // row carrying a band and a "Nothing found" chip, and a territory the provider does not cover is
+  // neither: filing it under "Nothing found" would state a clean result for a register nobody read,
+  // which is the one fusion this file's court-decisions section exists to keep apart.
+  const plan = opts && opts.planTerritories;
+  const planned = plan && Array.isArray(plan.searched) ? plan.searched.map(String) : null;
+  const codes = (planned
+    ? [...new Set([...planned, ...bandBy.keys()])]
+    : Object.keys(byC)).filter((c) => c !== 'WO');
+  if (!codes.length) return '';
   const alias = { EM: 'EU', GB: 'UK' };
-  const withF = [], clean = [];
+  // ONE ROW PER COUNTRY, DEDUPED AFTER THE ALIAS AND NOT BEFORE. The archive wrote each country once, so
+  // this loop never had to ask; a plan carries both spellings — the register's EM and GB alongside the EU
+  // and UK a reader knows — and aliasing them afterwards produced two EU rows and two UK rows on the
+  // first worldwide run measured through it. The band is looked up across every raw code that folded
+  // into the key, so a conflict recorded under EM still reaches the EU row.
+  const rawByKey = new Map();
   for (const c of codes) {
     const key = alias[c] || c;
-    (bandBy.has(c) || bandBy.has(key) ? withF : clean).push({ code: key, name: regionName(c) || c, band: bandBy.get(c) || bandBy.get(key) });
+    if (!rawByKey.has(key)) rawByKey.set(key, []);
+    rawByKey.get(key).push(c);
+  }
+  const withF = [], clean = [];
+  for (const [key, raws] of rawByKey) {
+    const c = raws.find((r) => bandBy.has(r)) ?? raws[0];
+    // THE NAME IS LOOKED UP ON THE ALIASED KEY, NOT THE RAW CODE. The register writes the EUIPO and
+    // ISO spellings — EM and GB — and `alias` maps those to the codes a reader knows, EU and UK. The
+    // name was resolved from the RAW code, which has no entry under either spelling, so it fell back
+    // to the code itself and the row read "EU EM" and "UK GB": a country column printing a second
+    // code, beside the four rows where the register happened to write the code we already knew.
+    // The raw code is still tried, so anything the alias does not cover resolves exactly as before.
+    const name = regionName(key) || regionName(c) || key;
+    (bandBy.has(c) || bandBy.has(key) ? withF : clean).push({ code: key, name, band: bandBy.get(c) || bandBy.get(key) });
   }
   if (!withF.length && !clean.length) return '';
   const rows = withF.map((c) => `<div class="wrow"><span class="rcode">${esc(c.code)}</span><span class="wname">${esc(c.name)}</span><span class="kc">${esc(c.band)}</span></div>`).join('');
   const cleanHtml = clean.length
     ? `<div class="wclean"><span class="wk">Nothing found</span>${clean.map((c) => `<span class="wchip" title="${escAttr(c.name)}">${esc(clean.length > 12 ? c.code : c.name)}</span>`).join('')}</div>`
     : '';
-  return `<div class="sec" id="countries"><h2>Where it stands</h2></div>
+  return `<div class="sec" id="countries"><span class="num"></span><h2>Where it stands</h2></div>
   <div class="panel where">${rows}${cleanHtml}</div>`;
 }
 
@@ -1027,17 +1113,29 @@ function whereItStandsSection(findings, opts) {
 function courtDecisionsSection(opts) {
   const sd = opts && opts.searchDepth;
   if (!sd || !sd.counts || !isFullCountry(opts)) return '';
-  const state = sd.counts.courtDecisions;
-  const byC = sd.counts.recordsByCountry || {};
+  const line = courtLineFor(opts, sd.counts.courtDecisions);
+  if (!line) return '';
+  return `<div class="sec" id="court"><span class="num"></span><h2>Court decisions</h2></div>
+  <div class="panel courtp"><p>${esc(line)}</p></div>`;
+}
+
+// The court section's sentence for a state, and the one the Court decisions row carries under its state
+// word when the research could not be completed — one sentence, said in both places in the same words.
+function courtLineFor(opts, state) {
+  const sd = opts && opts.searchDepth;
+  const byC = (sd && sd.counts && sd.counts.recordsByCountry) || {};
   const first = Object.keys(byC).filter((c) => c !== 'WO')[0];
   const where = first ? (regionName(first) || first) : '';
+  // The country comes from the record listing, so a run whose provider archives nothing has no name to
+  // put here — and every branch below embedded it mid-sentence. The page then read "Case-law research
+  // could not be completed for ." Each clause is now attached to the name rather than assuming one:
+  // same words when there is a country, one clause shorter when there is not.
+  const forWhere = where ? ` for ${where}` : '';
   let line = '';
-  if (state === 'not-checked') line = `Case-law research could not be completed for ${where}.`;
-  else if (state === 'none-found') line = `Court decisions: none found for ${where}.`;
-  else if (state === 'found') line = `Court decisions were searched for ${where} and are cited against the findings above.`;
-  if (!line) return '';
-  return `<div class="sec" id="court"><h2>Court decisions</h2></div>
-  <div class="panel courtp"><p>${esc(line)}</p></div>`;
+  if (state === 'not-checked') line = `Case-law research could not be completed${forWhere}.`;
+  else if (state === 'none-found') line = `Court decisions: none found${forWhere}.`;
+  else if (state === 'found') line = `Court decisions were searched${forWhere} and are cited against the findings above.`;
+  return line;
 }
 
 // Counts only, folded closed. A count of records read is engine activity rather than something a reader
@@ -1052,16 +1150,72 @@ function whatWasSearchedSection(opts, coverage = [], findings = [], recordsByUri
   const sd = opts && opts.searchDepth;
   const open = (Array.isArray(coverage) ? coverage : []).filter((c) => COV_STATE[c?.state]?.cls !== 'ok');
   const c = (sd && sd.counts) || {}, rows = [];
+  // THE REGISTER ROW, AS THE BOARDS DRAW IT: one line of totals — records read across the countries, plus
+  // the international registrations apart from them — and the per-country counts as chips under it, code
+  // first and the name on hover. One country is named in the line instead ("141 records read in Japan"),
+  // and draws no chips: a single chip would repeat the line.
   const byC = c.recordsByCountry || {};
-  const per = Object.entries(byC).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${regionName(k) || k} ${n.toLocaleString('en-GB')}`).join(' \u00b7 ');
-  if (per) rows.push(['Register records read', per]);
+  const intl = Number(byC.WO) || 0;
+  const countries = Object.entries(byC).filter(([k, n]) => k !== 'WO' && Number(n) > 0).sort((a, b) => b[1] - a[1]);
+  const read = countries.reduce((t, [, n]) => t + Number(n), 0);
+  if (countries.length || intl) {
+    const where = countries.length === 1 ? ` in ${regionName(countries[0][0]) || countries[0][0]}`
+      : countries.length ? ` across ${countries.length.toLocaleString('en-GB')} countries` : '';
+    const plus = intl ? `${countries.length ? ', plus ' : ''}${intl.toLocaleString('en-GB')} international registration${intl === 1 ? '' : 's'}` : '';
+    const line = `${countries.length ? `${read.toLocaleString('en-GB')} record${read === 1 ? '' : 's'} read${where}` : ''}${plus}`;
+    const chips = countries.length > 1
+      ? `<div class="wchips">${countries.map(([k, n]) => `<span class="wchip" title="${escAttr(regionName(k) || k)}">${esc(k)} <b>${Number(n).toLocaleString('en-GB')}</b></span>`).join('')}</div>`
+      : '';
+    rows.push(['Register', { html: `${esc(line)}${chips}` }]);
+  }
   const sw = c.sweep || {};
   if (sw.spellings) rows.push(['Spellings searched', String(sw.spellings)]);
-  if (sw.checks) rows.push(['Marketplace and web', `${sw.checks.toLocaleString('en-GB')} checks across ${sw.platforms} platforms`]);
+  if (sw.checks) rows.push(['Marketplace and web', `${sw.checks.toLocaleString('en-GB')} checks on ${sw.platforms} platforms`]);
   if (sw.reputation) rows.push(['Reputation and meaning', `${sw.reputation.toLocaleString('en-GB')} checks`]);
-  rows.push(['Local-script spellings', c.localScriptSearched ? 'searched' : 'not searched']);
-  const cd = { 'found': 'found', 'none-found': 'none found', 'not-checked': 'could not be checked', 'not-in-scope': 'not part of this search' }[c.courtDecisions];
-  if (cd) rows.push(['Court decisions', cd]);
+  rows.push(['Local-script spellings', c.localScriptSearched ? 'Searched' : 'Not searched']);
+  // HOW DEEP THE LOCAL-LANGUAGE INVESTIGATION WENT, which is a different question from the row above it.
+  // That one answers whether the spellings were searched; this one answers whether the investigation ran
+  // at the depth the matter configured. The engine can run it shallower than the account asked for, and
+  // it used to say so in exactly one place — a sentence a model wrote into the Methodology paragraph the
+  // redesign replaced with named rows — so a run that went shallow said so on no page at all.
+  //
+  // EVERY ONE OF THE FOUR WORDS IS ALREADY ON THE PAGE. "Included" and "Not part of this search" are the
+  // approved board's own values for this row; "Partially covered" and "Not run this run" are the coverage
+  // vocabulary this file already renders, taken from COV_STATE rather than retyped so they cannot drift
+  // apart from it. Nothing here composes a sentence.
+  //
+  // A state this table has no word for draws NO ROW, rather than the nearest word. The four are the whole
+  // set the record can produce, so the fallthrough is unreachable today and is there for the fifth state
+  // somebody adds: a row is a claim about a client's search, and the nearest word to an unknown state is
+  // a claim nobody checked.
+  const LL_WORD = {
+    ran: 'Included',
+    'ran-shallow': COV_STATE['coverage-limited'].word,
+    'not-run': COV_STATE['not-searched'].word,
+    'not-in-scope': 'Not part of this search',
+  };
+  //
+  // AND THE ROW NEEDS A LANE RECORD BEHIND IT, not just a state. The state folds to `not-in-scope` when
+  // there is no lane record at all, which is right for a clearance that never asked for the
+  // investigation and WRONG for a run that asked and whose record was never written. Measured on the
+  // full country demo: its own coverage carries "Native-language investigation depth / ja — the
+  // configured depth for this lane was full and this run delivered a depth this run cannot establish",
+  // and the state beside it reads not-in-scope, so this row would have told that reader the
+  // investigation was not part of their search. An empty `lanes` map is that absence, and an absence is
+  // not a finding — so the row is drawn from a record and not from a default. A run whose record exists
+  // draws it on every one of the four states.
+  const llLanes = c.localLanguage?.lanes;
+  const llRecorded = !!llLanes && typeof llLanes === 'object' && Object.keys(llLanes).length > 0;
+  const ll = llRecorded ? LL_WORD[c.localLanguage?.state] : null;
+  if (ll) rows.push(['Local-language investigation', ll]);
+  // COURT DECISIONS, AS THE FULL COUNTRY BOARD DRAWS THE ROW: its state, and for a search that could not
+  // be completed, the same sentence the court section under it prints. A search that does not include
+  // court decisions draws no row, as the other boards draw none.
+  const cdWord = { 'found': 'Found', 'none-found': 'None found', 'not-checked': 'Not searched' }[c.courtDecisions];
+  if (cdWord && isFullCountry(opts)) {
+    const why = c.courtDecisions === 'not-checked' ? courtLineFor(opts, 'not-checked') : '';
+    rows.push(['Court decisions', { html: `<span class="wstate">${esc(cdWord)}</span>${why ? `<span class="wnote">${esc(why)}</span>` : ''}` }]);
+  }
   const openHtml = open.length ? `<div class="openrows"><div class="rk">Left open</div>${coverageGrid(open)}</div>` : '';
   // THE LEGEND FOR WHAT IS ON THE CARDS, kept when the scope fold went. It is not the engine narrating
   // its own searching — it is what a linked registration number opens, why the rest are cited by number,
@@ -1073,16 +1227,30 @@ function whatWasSearchedSection(opts, coverage = [], findings = [], recordsByUri
   const prov = (hasRecordSet || hasCards)
     ? `<div class="provwrap"><div class="rk">Record provenance</div><p class="provnote">${hasRecordSet ? 'Registration numbers on the cards were read from the register records. ' : ''}${officeLinkNote()}${hasIndexEntry ? 'A registration shown as a register-index entry was seen in the register index; its full record was not pulled. ' : ''}\u201cInferred\u201d beside an owner\u2019s likelihood to object means we judged it from what the owner sells and holds; we had no enforcement history to read.</p></div>`
     : '';
+  // THE BOARDS END THE SECTION WITH THE WORKBOOK: every search and its result are in the audit workbook,
+  // which is where a reader who wants the record goes.
+  const more = opts?.auditFile
+    ? `<div class="cmore"><a class="wb" href="${escAttr(opts.auditFile)}">Every search and result, in the audit workbook</a></div>` : '';
   if (!rows.length && !openHtml && !prov) return '';
-  return `<details class="searched"><summary><span class="gname">What was searched</span><span class="gcount">Counts for this search</span></summary><div class="gbody">${
-    rows.map(([k, v]) => `<div class="row"><span class="k">${esc(k)}</span><span class="v">${esc(v)}</span></div>`).join('')}${openHtml}${prov}</div></details>`;
+  return `<div class="sec" id="searched"><span class="num"></span><h2>What was searched</h2></div>
+  <details class="searched"><summary><span class="gname">Counts for this search</span></summary><div class="gbody">${
+    rows.map(([k, v]) => `<div class="row"><span class="k">${esc(k)}</span><span class="v">${typeof v === 'object' ? v.html : esc(v)}</span></div>`).join('')}${openHtml}${prov}${more}</div></details>`;
 }
 
 function alsoConsideredSection(ruledOut, recordsByUri = new Map(), opts = {}) {
   const sd = opts.searchDepth || null;
   const ruledCards = ruledOut.map((f) => {
     const who = recordOwner(f, recordsByUri) || f.owner?.name || '';
-    const why = f.ruled_out_reason ? esc(f.ruled_out_reason) : 'a different name in a related field — not a conflict with your mark';
+    // THE ENGINE'S OWN SENTENCE LEADS THE CARD. The face printed a fixed line — "a different name in
+    // a related field" — on every ruled-out card, whatever the run had actually concluded. `net` is the
+    // finding's own one-line reason, written for a reader, and it was rendered NOWHERE: not on the
+    // face, not in the fold, not anywhere on the page. So a client read the same generic sentence
+    // about every name we set aside, while the specific reason we set THAT one aside was discarded at
+    // render time. The fold keeps the legal and practical positions, which are the longer argument.
+    // The fixed line stays as the last resort, for a finding that carries neither.
+    const why = f.ruled_out_reason ? esc(f.ruled_out_reason)
+      : f.net ? esc(String(f.net))
+      : 'a different name in a related field — not a conflict with your mark';
     const legal = f.legal_position ? esc(String(f.legal_position)) : '';
     const practical = f.practical_position ? esc(String(f.practical_position)) : '';
     const fold = (legal || practical)
@@ -1094,7 +1262,7 @@ function alsoConsideredSection(ruledOut, recordsByUri = new Map(), opts = {}) {
   const groups = clearedGroupsHtml(sd, opts.auditFile);
   const web = webNamesHtml(sd);
   if (!ruledCards && !groups && !web) return '';
-  return `<div class="sec" id="also-considered"><h2>Also considered</h2></div>
+  return `<div class="sec" id="also-considered"><span class="num"></span><h2>Also considered</h2></div>
   <div class="panel alsocons">${ruledCards ? `<div class="ruled-cards">${ruledCards}</div>` : ''}${groups || web ? `<div class="cgroups">${groups}${web}</div>` : ''}</div>`;
 }
 
@@ -1284,36 +1452,19 @@ function keyPanel(findings, recordsByUri = new Map()) {
 // complete in one place. The rights-holder landscape panel keeps its "Common-law" group — that
 // panel is the index of everything, this section is the reading surface.
 function commonLawSection(clSecondary, clOnField, cardFor, recordsByUri = new Map(), allFindings = []) {
-  // T7 (E4) — "what the marketplace layer added": for every REGISTER finding whose use
-  // evidence came from the common-law layer (a use_check cite), one attributed line with the A4
-  // confidence four-tuple + source class — the layer's contribution is visible and attributed, not
-  // buried in prose. Renders even when there are no common-law FINDINGS (contributions alone earn
-  // the section). On-field common-law conflicts keep their FULL cards in the risk-ordered band above
-  // (blocking-power ordering wins; E2's grouping complaint was the per-jurisdiction Marks list, which
-  // secondary CL left in A5) — cross-linked from here.
-  const contrib = (allFindings ?? [])
-    .filter((f) => f && f.disposition !== 'withdrawn' && f.use_check?.source && regionCode(f) !== COMMON_LAW)
-    .map((f) => {
-      // D4 — the evidence pair is LABELLED here too, and it reads out of the one USE_SOURCE_LABEL.
-      const st = useEvidence(f.meters?.use);
-      // D7 — the sentinel is mapped to client words BEFORE the URL parse is attempted. It is not a
-      // URL, so `new URL` threw and the catch printed `host.slice(0, 40)` — and the sentinel is 31
-      // characters, so the page printed the raw tool name, whole.
-      const raw = String(f.use_check.source);
-      let where;
-      if (isUseCheckNoResult(raw)) where = USE_CHECK_NO_RESULT_SHORT;
-      else { try { where = new URL((raw.match(/https?:\/\/[^\s,|]+/) || [raw])[0]).host; } catch { where = raw.slice(0, 40); } }
-      return `<li style="margin:3px 0"><a href="#c${f.ordinal}">#${f.ordinal} ${esc(f.mark)}</a> — use ${esc(humanize(f.meters?.use?.token ?? 'unknown'))} — ${esc(where)}${st ? ` <i class="evstat">(evidence: ${esc(st)})</i>` : ''}</li>`;
-    }).join('');
-  const contribBlock = contrib
-    ? `<p style="margin:4px 0 2px;font-size:13px"><b>What the marketplace layer added to register findings</b></p><ul style="margin:0 0 10px;padding-left:20px;font-size:13px">${contrib}</ul>`
-    : '';
-  if (!clSecondary.length && !clOnField.length && !contribBlock) return '';
+  // THE LAYER'S CONTRIBUTION IS ON THE CARD THAT CARRIES IT, NOT ALSO IN A LIST ABOVE THEM. A
+  // block headed "what the marketplace layer added to register findings" restated, per finding, the
+  // use token, the host and the evidence pair that the finding's OWN card already states in its use
+  // line — measured on the delivered reports: one such line per finding with use evidence, on the
+  // card, in every case the block listed. It attributed a layer to itself in the engine's own terms
+  // and made a reader read the same fact twice, the second time out of the context that explains it.
+  // Nothing is lost with it: the cards it linked to sit directly below.
+  if (!clSecondary.length && !clOnField.length) return '';
   const links = clOnField.length
     ? `<p class="clx" style="margin:4px 0 10px;font-size:13.5px">On-field common-law conflicts (full cards above): ${clOnField.map(f => `<a href="#c${f.ordinal}">#${f.ordinal} ${esc(f.mark)}</a>`).join(' · ')}</p>`
     : '';
   const cards = clSecondary.map(f => compactCard(f, cardFor(f), recordsByUri)).join('\n  ');
-  return contribBlock + links + cards;
+  return links + cards;
 }
 
 // Secondary findings → collapsible region groups (§2.4). Same region order as the key panel; each region a
@@ -1632,11 +1783,20 @@ function fullDetail(f, card, recordsByUri = new Map()) {
   // preparation is portal-report.mjs's job, never a second render fork here.
   const clHead = clProfile ? `<b>Case-law${clProfile.jurisdiction ? ` (${esc(clProfile.jurisdiction)})` : ''}.</b>` : '';
   const clBody = !clProfile ? '' : renderProse(clProfile.body);   // one report: the full body (renderProse handles ::p:: internal lines)
-  const caseLawStrand = clProfile
+  // Only a pass that FOUND precedent puts a strand on the card. Where none was found, or the research
+  // could not be completed, the body is the engine's account of the attempt and the Court decisions
+  // section says the outcome plainly on its own; repeating it here said it twice, the second time in
+  // the machinery's voice on the card a client reads most closely.
+  const caseLawStrand = clProfile && COURT_DECISIONS !== 'not-checked' && COURT_DECISIONS !== 'none-found'
     ? `<div class="clstrand" style="margin:10px 0 0;padding-top:8px;border-top:1px dashed var(--line,#ddd)">${clHead}${clBody}</div>`
     : '';
   const link = f.source?.resolved_link;
-  const prov = link ? `<div class="prov">audit ref F${f.ordinal} · <a href="${esc(link)}" target="_blank" rel="noopener noreferrer">${esc(link.replace(/^https?:\/\//, '').slice(0, 48))}</a></div>` : `<div class="prov">audit ref F${f.ordinal}</div>`;
+  // NO AUDIT REFERENCE ON A CLIENT'S CARD. "audit ref F1" is the engine's handle for the finding —
+  // it indexes the workbook, it means nothing to the reader holding the report, and the mock carries no
+  // such line. The SOURCE LINK stays: it is the only address a reader has for the record on this card
+  // until the workbook row lands beside it, and dropping both would take a fact away rather than a
+  // label. With no link there is nothing left to say, so the row does not render at all.
+  const prov = link ? `<div class="prov"><a href="${esc(link)}" target="_blank" rel="noopener noreferrer">${esc(link.replace(/^https?:\/\//, '').slice(0, 48))}</a></div>` : '';
   // WP-receipts W4 — the code-owned senior-right line (Owner decision 2026-07-05: VERY SIMPLE CLEAR ENGLISH,
   // stated qualification, verdict untouched). Verified senior → nothing extra (the W2 receipt line on
   // the fetched leg is the proof). Unverified → the open item, plainly, where the finding lives.
@@ -2059,8 +2219,7 @@ window.addEventListener('hashchange',_cardHashGo);
 window.addEventListener('load',_cardHashGo);
 window.addEventListener('beforeprint',function(){document.querySelectorAll('details').forEach(function(d){d.dataset.o=d.open?'1':'';d.open=true;});});
 window.addEventListener('afterprint',function(){document.querySelectorAll('details').forEach(function(d){d.open=d.dataset.o==='1';});_hidden.forEach(function(c){c.classList.remove('print-hidden');});_hidden=[];});
-document.addEventListener('click',function(e){var t=e.target.closest('.tb-exp-toggle'),pop=document.querySelector('.tb-exp-pop');if(t){if(pop){pop.hidden=!pop.hidden;t.setAttribute('aria-expanded',String(!pop.hidden));}return;}if(pop&&!pop.hidden&&!e.target.closest('.tb-exp-pop')){pop.hidden=true;var b=document.querySelector('.tb-exp-toggle');if(b)b.setAttribute('aria-expanded','false');}});
-document.addEventListener('keydown',function(e){if(e.key==='Escape'){var pop=document.querySelector('.tb-exp-pop');if(pop&&!pop.hidden){pop.hidden=true;var b=document.querySelector('.tb-exp-toggle');if(b)b.setAttribute('aria-expanded','false');}}});`;
+${EXPORT_MENU_JS}`;
 
 // Render a parsed report + findings.json to a full self-contained HTML string.
 // A1 — famous-neighbour context notes: knowledge-cited references kept for diligence (digest.md's "never
@@ -2080,7 +2239,7 @@ document.addEventListener('keydown',function(e){if(e.key==='Escape'){var pop=doc
 function markAssessmentBlock(ma) {
   if (ma == null) return '';
   const structured = typeof ma.distinctiveness === 'object' || typeof ma.connotation === 'object';
-  const SEC = `<div class="sec"><h2>The mark itself</h2></div>`;
+  const SEC = `<div class="sec"><span class="num"></span><h2>The mark itself</h2></div>`;
   if (!structured) {
     const dist = String(ma?.distinctiveness ?? '').trim(), conn = String(ma?.connotation ?? '').trim();
     if (!dist && !conn) return '';
@@ -2150,7 +2309,7 @@ function contextNotesList(notes = []) {
 // the findings-section assembly below.
 function contextNotesBlock(notes = []) {
   if (!notes.length) return '';
-  return `<div class="sec"><h2>Famous-mark neighbours noted</h2></div>
+  return `<div class="sec"><span class="num"></span><h2>Famous-mark neighbours noted</h2></div>
   ${contextNotesList(notes)}`;
 }
 
@@ -2283,6 +2442,13 @@ function depthStripHtml(note) {
 }
 
 // Signature: renderHtml(parsed, findings, coverage, opts). ONE render path — there is no client variant.
+// THE BOARD'S FIVE ENTRIES, in its order. The rule that filters them lives in shared/brand.mjs, because
+// the knockout renderer draws a strip from its own board and the filtering is the half worth having once.
+const STRIP = Object.freeze([
+  ['summary', 'Summary'], ['findings', 'Findings'], ['also-considered', 'Also considered'],
+  ['next', 'Next steps'], ['searched', 'What was searched'],
+]);
+
 export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   if (findings && !Array.isArray(findings)) { opts = findings; findings = []; coverage = []; }  // tolerate legacy (parsed, opts)
   AS_OF = opts.asOf ?? null;   // C2
@@ -2292,6 +2458,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   SEARCHED_JUR = Array.isArray(opts.searchedJurisdictions) && opts.searchedJurisdictions.length ? opts.searchedJurisdictions : null;   // T6 (D4)
   SCOPE_WORLDWIDE = opts.scopeBasis === 'worldwide' ? true : null;   // the plan's scope_basis; null ⇒ fall back to the ledger-prose sniff
   CASE_LAW_BY_ORD = opts.caseLawByOrdinal instanceof Map ? opts.caseLawByOrdinal : new Map();   // T7 (E5)
+  COURT_DECISIONS = opts.searchDepth?.counts?.courtDecisions ?? null;   // gates the card's case-law strand
   ENFORCER_SIGNALS = new Map((Array.isArray(opts.enforcerSignals) ? opts.enforcerSignals : []).map((e) => [String(e.uri ?? '').toLowerCase(), e]));   // T7 (E6)
   RECORD_ORIGIN = opts.recordOrigin ?? null;       // WP-receipts W2
   // — `null` and `` mean DIFFERENT things and the render must not collapse them. `` is an
@@ -2429,13 +2596,13 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   const hasCL = Boolean(clBody);
   let findingsSections, covNum;
   if (!DISPOSITION_MODE) {
-    findingsSections = `${onField.length ? `<div class="sec"><h2>The conflict landscape</h2></div>
+    findingsSections = `${onField.length ? `<div class="sec" id="findings"><span class="num"></span><h2>The conflict landscape</h2></div>
   <div class="landwrap">${quadrant(sorted)}${keyPanel(sorted, recordsByUri)}</div>
 
-  <div class="sec"><h2>Conflicts</h2></div>
+  <div class="sec"><span class="num"></span><h2>Conflicts</h2></div>
   ${onField.map(f => findingCard(f, cardFor(f), recordsByUri)).join('\n  ')}` : ''}
 
-  ${secReg.length ? `<div class="sec"><h2>Secondary &amp; watch</h2></div>
+  ${secReg.length ? `<div class="sec"><span class="num"></span><h2>Secondary &amp; watch</h2></div>
   ${secondaryRegions(secReg, cardFor, recordsByUri)}` : ''}${hasCL ? `
 
   ${clBody}` : ''}`;
@@ -2444,10 +2611,10 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
     let secNum = 0;
     const num = () => String(++secNum).padStart(2, '0');
     const landscape = onField.length
-      ? `<div class="sec"><h2>The conflict landscape</h2></div>
+      ? `<div class="sec" id="findings"><span class="num"></span><h2>The conflict landscape</h2></div>
   <div class="landwrap">${quadrant(sorted)}${keyPanel(sorted, recordsByUri)}</div>
 
-  <div class="sec"><h2>Conflicts</h2></div>
+  <div class="sec"><span class="num"></span><h2>Conflicts</h2></div>
   ${onField.map(f => findingCard(f, cardFor(f), recordsByUri)).join('\n  ')}`
       : '';
     // THE COMMON-LAW CARDS GO WITH THE CONFLICTS, NOT UNDER THE NEXT HEADING. Appended at the end they
@@ -2474,7 +2641,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
       const notes = contextNotes.length ? `\n  <p class="fold-lead"><b>Famous-mark neighbours.</b> Diligence — no register record; not scored, does not affect the risk read.</p>
   ${contextNotesList(contextNotes)}` : '';
       if (negatives.total || notes) {
-        tail += `\n\n  <div class="sec"><h2>Notable but manageable</h2></div>
+        tail += `\n\n  <div class="sec"><span class="num"></span><h2>Notable but manageable</h2></div>
   ${negatives.total ? reasonedNegatives(negatives.groups, cardFor, recordsByUri) : ''}${notes}`;
       }
     } else if (band2r.length || band3r.length || contextNotes.length) {
@@ -2484,7 +2651,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   ${secondaryRegions(band3r, cardFor, recordsByUri)}`);
       if (contextNotes.length) parts.push(`<p class="fold-lead"><b>Famous-mark neighbours.</b> Diligence — no register record; not scored, does not affect the risk read.</p>
   ${contextNotesList(contextNotes)}`);
-      tail += `\n\n  <div class="sec"><h2>Notable but manageable</h2></div>
+      tail += `\n\n  <div class="sec"><span class="num"></span><h2>Notable but manageable</h2></div>
   ${parts.join('\n  ')}`;
     }
     // The 2026-09-16 report redesign — the section heading and its routing notice go; the CARDS stay, or a
@@ -2514,7 +2681,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   const linkChrome = !!opts.chromeHref;
   const cssInline = REPORT_BASE + '\n' + (linkChrome ? '' : NAV_SHEET) + '\n' + REP_OVERRIDE;
   const chromeLinkTag = linkChrome ? `<link rel="stylesheet" href="${escAttr(opts.chromeHref)}">` : '';
-  return `<!DOCTYPE html>
+  const doc = `<!DOCTYPE html>
 <html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1">
 <title>${productName ? `${esc(productName)} — ` : ''}${esc(fm.title || '')} · ${esc(BRAND.name)}</title>
 <link rel="preconnect" href="https://api.fontshare.com" crossorigin>
@@ -2530,11 +2697,20 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   <span class="sp"></span>
   <span class="tb-risk" style="background:var(${STOP_VAR[i]})">${riskLabel}</span>
   <span class="mono tb-matter" style="font-size:11px;color:var(--faint)">${esc(fm.matter || opts.runId || '')}${fm.title ? ' / ' + esc(fm.title) : ''}</span>
-  ${opts.issued ? `<span class="mono tb-issued"><span aria-hidden="true">🗓 </span>Issued on ${esc(opts.issued)}</span>` : ''}
+  ${/* A DATE, NOT A TIMESTAMP. This read "Issued on 2026-09-17 · 08:36 GMT+2" — the minute the file
+       was written, and the zone the machine that wrote it happened to be in. Neither tells a reader
+       anything, and on work that spans days it implies a precision the work does not have. Every mock
+       issues the date alone. Taken by PATTERN rather than by cutting at the separator, so a value in
+       some other shape falls through whole instead of being truncated at whatever character sits
+       there — an archived run's stamp is not this publisher's to assume. */''}
+  ${(() => {
+    const d = (String(opts.issued ?? '').match(/^\d{4}-\d{2}-\d{2}/) || [])[0] ?? opts.issued;
+    return d ? `<span class="mono tb-issued"><span aria-hidden="true">🗓 </span>Issued on ${esc(d)}</span>` : '';
+  })()}
   <button type="button" class="tbbtn tb-ask no-print">✦ <span class="tb-lbl">Ask AI</span></button>
   <div class="tb-menu">
-    <button type="button" class="tbbtn primary tb-exp-toggle" aria-haspopup="true" aria-expanded="false">⬇ <span class="tb-lbl">Export</span> ▾</button>
-    <div class="tb-pop tb-exp-pop" hidden>
+    ${EXPORT_TOGGLE}
+    ${exportPopover(`
       <div class="tb-pop-title">Export &amp; audit</div>
       <button class="util primary" onclick="exportPDF()">⬇ Export PDF (ticked findings)</button>
       ${excelBtn2}
@@ -2542,15 +2718,16 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
       <div class="tb-row"><button class="util" onclick="pickAll(true)">Select all</button><button class="util" onclick="pickAll(false)">Select none</button></div>
       <div class="tb-row"><button class="util" onclick="openAll(true)">Expand all</button><button class="util" onclick="openAll(false)">Collapse all</button></div>
       <p class="tb-hint">Tick a finding to keep it in the exported PDF; untick to drop it. Internal (review-only) notes are removed on export.</p>
-    </div>
+    `)}
   </div>
 </div>
+<!--SECTION-STRIP-->
 </div>
 
 <div class="wrap">
   <!-- doc-52 §1 THE VERDICT — the answer leads: mark · band · one plain "subject to" line · the lawyer's
        questions answered · the time-critical alert. Process + coverage detail are below and collapsible. -->
-  <header class="hero">
+  <header class="hero" id="summary">
     ${demoBannerHtml(opts.demoData === true)}
     ${confLineHtml(opts.delivery, productName)}
     <h1 class="mark">${esc(fm.title || '')}</h1>
@@ -2576,7 +2753,7 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   ${alsoConsideredSection(ruledOut, recordsByUri, opts)}
 
   <!-- doc-52 §3 WHAT ONLY YOU CAN CLOSE — forward decisions, plain English, after the findings. -->
-  ${buckets.you ? `<div class="sec" id="only-you"><h2>What only you can close</h2></div>
+  ${buckets.you ? `<div class="sec" id="next"><span class="num"></span><h2>What happens next</h2></div>
   <div class="panel actions"><div class="actgrp act-you">${renderProse(buckets.you.body)
     .replace(/\[Time-critical\]\s*/gi, '<span class="src cl" style="margin-right:6px">Time-critical</span> ')
     .replace(/\[Open question\]\s*/gi, '<span class="src" style="margin-right:6px">Open question</span> ')
@@ -2598,25 +2775,57 @@ export function renderHtml(parsed, findings = [], coverage = [], opts = {}) {
   ${whatWasSearchedSection(opts, coverage, findings, recordsByUri)}
 
   <footer>
-    <span>${productName ? `${esc(productName)}. ` : ''}${FRAMEWORK
-        // TWO SENTENCES, and that count is the ruled shape rather than a consequence of trimming.
-        //
-        // Two things left. The band note — "the framework in force's own vocabulary, one word per
-        // finding on every surface" — is a note about how the renderer works, printed on every report a
-        // client receives; the framework's NAME is on the "Rated under" line below, once, which is
-        // where a reader who wants it will look.
-        //
-        // AND "Working draft for legal review.", which is a separate decision and is recorded as one.
-        // A delivered clearance is not a draft, and a document that calls itself one on every page is
-        // describing its own status inaccurately to the person paying for it. Raised in review because
-        // the first version of this comment argued only the band note and left the reader to infer that
-        // the status line had gone along for the ride.
-        ? '' : ''}<br>Matter ${esc(fm.matter || '')}${fm.run ? ` · ${esc(fm.run)}` : ''}.${fm.rated_under ? `<br>Rated under: <span class="mono">${esc(fm.rated_under)}</span>.` : ''}${fm.run_under_project ? `<br>Run under project: <span class="mono">${esc(fm.run_under_project)}</span>.` : ''}</span>
+    ${/* ONE CLIENT LINE, AND IT NAMES WHAT EACH DATE IS. It ran to four.
+         "Rated under" STAYS, and it is not an oversight: the document carries the reviewer's
+         provenance and portal-report strips that one line for every embedded reader at serve time,
+         which is stated there and held by an arm. Deleting it here would take provenance off the
+         reviewer's copy to save the portal a job it already does.
+         "Run under project" also STAYS on the document, for the same reason and with the same
+         remedy. It is internal provenance — an end-to-end arm reads it out of the published internal
+         report, through the front-matter seam — and it was reaching clients only because nothing
+         removed it at serve time. It does now, beside the provenance line, so the document keeps what
+         review needs and the client reads neither. Deleting it here would have taken provenance off
+         the internal copy to fix a leak that belongs in the same place the other one is fixed.
+         The product name lead goes: the identity line already says which search this is.
+         The run string is composed as "<date> · <provider>", and it was printed with neither part
+         labelled, so a bare date sat next to a matter identifier meaning nothing in particular. It is
+         split on the DATE by pattern — the same way `dateOf` does it one file over — and the remainder
+         is the provider. A run string with no date in it is not this renderer's to take apart, so it
+         is printed whole and unlabelled rather than guessed at. */''}
+    <!-- WHICH MODELS SERVED THIS RUN. It used to close the scope fold, and the 2026-09-16 redesign
+         deleted that fold — so the line was re-homed rather than dropped with its container, which
+         would have removed a statement of provenance from the client's page as a side effect of a
+         merge. Owner ruling, 2026-09-17: it belongs in the footer, beside the matter and the framework.
+         It renders as '' on a run that recorded no models, so an archived run republishes exactly as
+         delivered, and the call sits ADJACENT so the whitespace around it belongs to the line and goes
+         with it — the freeze tool sets this paragraph aside by a pattern that takes the space before
+         it. -->${servedModelsLine(opts.servedModels)}
+    <span>${(() => {
+      const runStr = String(fm.run ?? '').trim();
+      const searchedOn = (runStr.match(/\d{4}-\d{2}-\d{2}/) || [])[0] ?? null;
+      const provider = searchedOn
+        ? runStr.replace(searchedOn, '').replace(/^[\s\u00b7]+|[\s\u00b7]+$/g, '').trim()
+        : runStr;
+      const issuedOn = (String(opts.issued ?? '').match(/^\d{4}-\d{2}-\d{2}/) || [])[0] ?? opts.issued ?? null;
+      const parts = [
+        fm.matter ? `Matter ${esc(fm.matter)}` : '',
+        searchedOn ? `searched on ${esc(searchedOn)}` : '',
+        issuedOn ? `issued on ${esc(issuedOn)}` : '',
+        provider ? esc(provider) : '',
+      ].filter(Boolean);
+      const line = parts.length ? `${parts.join(' \u00b7 ')}.` : '';
+      // The reviewer's provenance rides BELOW the client line, where portal-report removes it.
+      // Both provenance lines ride BELOW the client line, where portal-report removes them.
+      return line
+        + (fm.rated_under ? `<br>Rated under: <span class="mono">${esc(fm.rated_under)}</span>.` : '')
+        + (fm.run_under_project ? `<br>Run under project: <span class="mono">${esc(fm.run_under_project)}</span>.` : '');
+    })()}</span>
     ${logoLockup({ mark: 16 })}
   </footer>
 </div>
 <script>${PAGE_JS}</script>
 </body></html>`;
+  return doc.replace('<!--SECTION-STRIP-->', sectionStrip(doc, STRIP));
 }
 
 // CLI:  node render.mjs <report.md> [findings.json] [outDir]
@@ -2658,3 +2867,24 @@ function officeLinkNote() {
   return (linked ? 'A registration number shown as a link opens the office’s own page for that record. ' : '')
     + officeReasonSentences(RECORD_LINKS).map((s) => `${esc(s)} `).join('');
 }
+
+// THE MODELS THAT SERVED THIS SEARCH, as one closing line of the scope section (2026-09-14). The ids are
+// the ones the engine reported for its turns (tokens.mjs servedModels), never the tier a stage asked
+// for in place of a model the engine named: every tier goes to the program as the vendor's alias, and an
+// alias names no model. Both report
+// kinds call this, so they say it in the same words. '' when the run recorded none, so a run published
+// before the record existed renders exactly as it was delivered.
+//
+// A TIER WORD IS CLAUDE'S. servedModels lists a turn served under a company's own deployment name as the
+// tier it asked for ("Opus"), never the name, so the list may read "claude-opus-5, Haiku". Both are
+// Claude's and the line says so once; in a list that also names another vendor, the word says it itself
+// ("Claude Opus"). The four words, Fable among them, are the ones servedModels writes. They are kept here
+// rather than imported, because tokens.mjs loads the driver's settings and this module renders without them.
+const CLAUDE_TIER_WORD_RE = /^(?:Opus|Sonnet|Haiku|Fable)$/;
+export function servedModelsLine(ids) {
+  const list = (Array.isArray(ids) ? ids : []).map((s) => String(s ?? '').trim()).filter(Boolean);
+  if (!list.length) return '';
+  const claude = list.every((id) => /^claude-/i.test(id) || CLAUDE_TIER_WORD_RE.test(id));
+  const shown = claude ? list : list.map((id) => (CLAUDE_TIER_WORD_RE.test(id) ? `Claude ${id}` : id));
+  return `<p class="servedby" style="margin:10px 0 0;font-size:13px">Prepared with${claude ? ' Claude' : ''}: ${shown.map(esc).join(', ')}.</p>`;
+}