@cspeach/cli 1.1.30 → 1.1.32

package/dist/register/status-file/register-model.js

@@ -12,14 +12,14 @@
  * measurement has none) or clean (measured, never had any). A developer's
  * "fixed" is a claim and is never counted here.
  */
-import { activeOf, provenOf, settledOf } from '@cspeach/register-core';
+import { activeOf, laneActiveOf, laneProvenOf, provenOf, settledOf } from '@cspeach/register-core';
 /**
  * The three counts every surface divides by are defined once, in register-core,
  * where the terminal reads them too. They are passed on from here so that
  * register-parts.js — which draws the lane table for both the page and the
  * status file — takes its numbers from the model, like everything else it draws.
  */
-export { activeOf, provenOf, settledOf };
+export { activeOf, laneActiveOf, laneProvenOf, provenOf, settledOf };
 /** Worst first: the order cells are banded in a block and listed in a legend. */
 export const STATE_ORDER = ['regressed', 'did-not-hold', 'untouched', 'decided', 'working', 'claimed', 'verified', 'clean', 'retired'];
 export const STATE_LABEL = {
@@ -79,6 +79,8 @@ const andList = (names) => (names.length < 3 ? names.join(' and ') : `${names.sl
 /** As many names as a person reads before they stop reading names. */
 const LIST_CAP = 12;
 const count = (value) => value.toLocaleString('en-US');
+/** A clean (or verified) object nobody decided: counted on its own, never as undecided. */
+export const NOTHING_TO_DECIDE = 'clean, nothing to decide';
 /**
  * How a cut list ends.
  *
@@ -145,11 +147,18 @@ export function summarize(register, { unreadable = 0 } = {}) {
     // A folder from an older build carries no `undecided`; work it out the same
     // way register-core does, so the line never prints a blank.
     const decided = totals.decided ?? 0;
-    const undecided = Number.isFinite(totals.undecided) ? totals.undecided : Math.max(0, totals.objects - decided);
+    // Recording fix 4 (2026-10-07): a clean object nobody decided has nothing
+    // to decide. register-core counts it on its own; it is never "undecided".
+    const nothingToDecide = Number.isFinite(totals.cleanNothingToDecide) ? totals.cleanNothingToDecide : 0;
+    const undecided = Number.isFinite(totals.undecided) ? totals.undecided : Math.max(0, totals.objects - decided - nothingToDecide);
+    const decidedPhrase = nothingToDecide > 0
+        ? `${count(decided)} decided${undecided > 0 ? `, ${count(undecided)} undecided` : ''} · ${count(nothingToDecide)} ${NOTHING_TO_DECIDE}`
+        : `${count(decided)} decided, ${count(undecided)} undecided`;
     return {
         objects: totals.objects, active: totals.active, proven, provenPct, decided: totals.decided, undecided, needAttention,
         lastMeasured, unreadable, fromFile,
-        line: `${plural(totals.objects, 'object', 'objects')} · ${provenPhrase}${fromFilePhrase} · ${count(decided)} decided, ${count(undecided)} undecided · ${plural(needAttention, 'needs attention', 'need attention')} · ${lastMeasured}`,
+        ...(nothingToDecide > 0 ? { nothingToDecide } : {}),
+        line: `${plural(totals.objects, 'object', 'objects')} · ${provenPhrase}${fromFilePhrase} · ${decidedPhrase} · ${plural(needAttention, 'needs attention', 'need attention')} · ${lastMeasured}`,
     };
 }
 const DAY_MS = 86_400_000;
@@ -199,6 +208,21 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
         items.push({ kind: 'exception-no-reason', title: `${plural(noReason.length, 'accepted exception has', 'accepted exceptions have')} no reason`,
             detail: upTo(noReason.map((o) => o.name), { tail: onMap }), keys: noReason.map((o) => o.key) });
     }
+    // A developer's "retire" is a candidate until the lead confirms it with a
+    // reason (spec 2026-10-06 D2). Until then the object stays active, and the
+    // lead is the one person who can move it.
+    const candidates = register.objects.filter((o) => o.retireCandidate === true);
+    if (candidates.length) {
+        items.push({ kind: 'retire-candidate', title: `${plural(candidates.length, 'retire candidate waits', 'retire candidates wait')} for your confirmation`,
+            detail: upTo(candidates.map((o) => o.name), { tail: onMap }), keys: candidates.map((o) => o.key) });
+    }
+    // Out of scope is a decision about work nobody will do, so it needs a reason
+    // the lead can defend. A record from an older build may carry none.
+    const outNoReason = register.objects.filter((o) => o.inScope === false && !o.scopeReason);
+    if (outNoReason.length) {
+        items.push({ kind: 'out-of-scope-no-reason', title: `${plural(outNoReason.length, 'object was', 'objects were')} taken out of scope with no reason`,
+            detail: upTo(outNoReason.map((o) => o.name), { tail: onMap }), keys: outNoReason.map((o) => o.key) });
+    }
     const unowned = register.objects.filter((o) => o.lane === null);
     if (unowned.length) {
         const packages = [...new Set(unowned.map((o) => o.package))].sort();
@@ -213,6 +237,16 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
         items.push({ kind: 'overlap', title: `${plural(overlap.length, 'object is', 'objects are')} claimed by more than one lane`,
             detail: upTo([...new Set(overlap.map((o) => o.laneOverlap.join(' + ')))].sort(), { tail: justHowMany, sep: '; ' }), keys: overlap.map((o) => o.key) });
     }
+    // Rows of the last Excel import that clashed with a change recorded after the
+    // workbook was made were skipped, not applied. Only the newest import counts:
+    // an older one's skips were either entered again or are no longer wanted.
+    const lastImport = (register.plan?.history ?? []).find((c) => c.action === 'excel');
+    const clashes = lastImport?.clashesSkipped ?? 0;
+    if (Number.isInteger(clashes) && clashes > 0) {
+        items.push({ kind: 'excel-clashes', title: `${plural(clashes, 'Excel plan row was', 'Excel plan rows were')} skipped at the last import`,
+            detail: 'They clashed with changes recorded after the workbook was made. Make a fresh workbook with cspeach team report and enter them again.',
+            keys: [] });
+    }
     // A lane that has finished its work stops writing records, and that is the
     // point — it is not quiet, it is done. Only a lane with work still open can
     // be waiting for someone.
@@ -220,8 +254,8 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
     for (const lane of register.lanes) {
         if (!lane.objects || !lane.lastRecordAt || !Number.isFinite(nowMs))
             continue;
-        if (lane.objects - settledOf(lane.byState) <= 0)
-            continue;
+        if (laneActiveOf(lane) - laneProvenOf(lane) <= 0)
+            continue; // the lane's own Done % denominator
         const days = Math.floor((nowMs - Date.parse(lane.lastRecordAt)) / DAY_MS);
         if (days >= quietDays) {
             items.push({ kind: 'quiet-lane', title: `${lane.owner} (${lane.id}): no records for ${plural(days, 'day', 'days')}`,

package/dist/register/status-file/register-parts.js

@@ -21,7 +21,7 @@
  * style attribute.
  */
 import { esc, blockSvg, legendHtml, levelLegendHtml, stateWord, LEVEL_BUCKETS as LEVELS, LEVEL_WORD as LEVEL_NAME } from './register-map.js';
-import { activeOf, formatWhen, measurementHistory, notMeasuredCount, provenOf, unknownStateCount, FROM_FILE, } from './register-model.js';
+import { formatWhen, laneActiveOf, laneProvenOf, measurementHistory, notMeasuredCount, provenOf, unknownStateCount, FROM_FILE, NOTHING_TO_DECIDE, } from './register-model.js';
 import { DISPOSITION_ORDER, DISPOSITION_WORD, developerTable, dispositionOf, overlapNote, } from '@cspeach/register-core';
 // The map owns it, because the map's cells need it too; it is offered here as
 // well, where every other shared mark lives.
@@ -119,6 +119,8 @@ export function lanesTableHtml(lanes, objects) {
     for (const o of objects ?? []) {
         if (o.measuredBasis !== 'file' || (o.state !== 'verified' && o.state !== 'clean'))
             continue;
+        if (o.inScope === false)
+            continue; // the same objects the lane's Proven counts
         // Every lane that claims the object, exactly as the lane's own counts are
         // taken: an object two lanes both claim is proven for both of them, so
         // "(n from a file)" can never be larger than the Proven it sits beside.
@@ -129,10 +131,10 @@ export function lanesTableHtml(lanes, objects) {
         .map((h) => `<th scope="col">${h}</th>`).join('');
     const provenCell = (l) => {
         const said = fromFile.get(l.id) ?? 0;
-        return `${n(provenOf(l.byState))}${said ? ` (${n(said)} ${FROM_FILE})` : ''}`;
+        return `${n(laneProvenOf(l))}${said ? ` (${n(said)} ${FROM_FILE})` : ''}`;
     };
     const row = (l) => `<tr><td>${esc(ownerLabel(l))}</td><td>${n(l.objects)}</td>`
-        + `<td>${n(activeOf(l.objects, l.byState))}</td><td>${provenCell(l)}</td>`
+        + `<td>${n(laneActiveOf(l))}</td><td>${provenCell(l)}</td>`
         + `<td>${n((l.byState?.regressed ?? 0) + (l.byState?.['did-not-hold'] ?? 0))}</td>`
         + `<td>${esc(formatWhen(l.lastRecordAt))}</td></tr>`;
     return `<div class="scroller"><table><thead><tr>${heads}</tr></thead>`
@@ -165,7 +167,7 @@ export function mapBodyHtml(register, blocks, { role, colourBy } = {}) {
         return '<p>No objects in scope yet.</p>';
     // The status file never passes `colourBy`: it prints the state map only.
     const legend = colourBy === 'level'
-        ? levelLegendHtml(register.totals.byLevel?.now, { retired: register.totals.byState?.retired ?? 0 })
+        ? levelLegendHtml(register.totals.byLevel?.now, { retired: register.totals.byState?.retired ?? 0, nothingToDecide: register.totals.byLevel?.nothingToDecide ?? 0 })
         : legendHtml(register.totals.byState, { unknown: unknownStateCount(register) });
     return `${legend}
       <div class="blocks">${blocks.map((b) => blockFigureHtml(b, { role, colourBy })).join('')}</div>`;
@@ -401,9 +403,10 @@ const CLASSIFICATION_WORD = { keep: 'keep', fix: 'fix', redesign: 'redesign', re
  * it (the caller escapes it), never as "not decided": somebody DID decide, and
  * calling it undecided would put the object in a bucket nobody chose.
  */
-export function decisionWord(decision, projectType) {
+export function decisionWord(decision, projectType, state) {
+    // Recording fix 4: a clean (or verified) object nobody decided has nothing to decide.
     if (!decision)
-        return 'not decided';
+        return state === 'clean' || state === 'verified' ? 'clean — nothing to decide' : 'not decided';
     if (projectType === 'clean-core') {
         const d = dispositionOf(decision);
         if (d)
@@ -428,6 +431,9 @@ export function whereItStandsHtml(register) {
         + tile('Proven', provenOf(s), fromFile ? `${n(fromFile)} of them ${FROM_FILE}` : 'a check run says so')
         + tile('Did not hold', didNotHold, 'claimed, and the check still finds it', didNotHold ? 'bad' : '')
         + tile('Retired', s.retired ?? 0, 'nothing left to do')
+        // Only when there are some: a developer said retire and the lead has not
+        // confirmed it yet, so these objects still count as active work.
+        + ((t.retireCandidates ?? 0) > 0 ? tile('Retire candidates', t.retireCandidates, 'wait for the lead to confirm', 'retire-candidates') : '')
         + '</ul>'
         + (!(t.decided > 0) ? '<p class="empty-note" data-role="nothing-decided">Nothing decided yet. Developers record decisions with /abap-clean-core or cspeach team decide.</p>' : '')
         + levelBarsHtml(register);
@@ -437,7 +443,7 @@ export function whereItStandsHtml(register) {
  * never stands alone. Segments are paths, not rects: a `rect` on these surfaces
  * is a map cell, and the budget and the keyboard both count cells by that tag.
  */
-function levelBar(title, counts) {
+function levelBar(title, counts, nothingToDecide = 0) {
     const total = LEVELS.reduce((sum, l) => sum + (counts?.[l] ?? 0), 0);
     let x = 0;
     const rects = total
@@ -451,7 +457,9 @@ function levelBar(title, counts) {
             return r;
         }).join('')
         : '<path class="lvl l-none" d="M0 0h100v10h-100z"></path>';
-    const words = LEVELS.map((l) => `${LEVEL_NAME[l]} ${n(counts?.[l] ?? 0)}`).join(' · ');
+    // A clean object nobody decided is not "not decided": it is said on its own, after the buckets.
+    const words = LEVELS.map((l) => `${LEVEL_NAME[l]} ${n(counts?.[l] ?? 0)}`).join(' · ')
+        + (nothingToDecide > 0 ? ` · ${NOTHING_TO_DECIDE} ${n(nothingToDecide)}` : '');
     return `<figure class="levelbar"><figcaption>${esc(title)}</figcaption>`
         + `<svg viewBox="0 0 100 10" preserveAspectRatio="none" role="img" aria-label="${esc(`${title}: ${words}`)}">${rects}</svg>`
         + `<p class="levelwords">${esc(words)}</p></figure>`;
@@ -460,7 +468,7 @@ function levelBar(title, counts) {
 export function levelBarsHtml(register) {
     const b = register.totals?.byLevel;
     const none = !b || ['A', 'B', 'C', 'D'].every((l) => !(b.decided?.[l]) && !(b.now?.[l]));
-    return `<div class="levels" data-role="levels">${levelBar('Levels at decision', b?.decided)}${levelBar('Levels now', b?.now)}`
+    return `<div class="levels" data-role="levels">${levelBar('Levels at decision', b?.decided, b?.nothingToDecide ?? 0)}${levelBar('Levels now', b?.now, b?.nothingToDecide ?? 0)}`
         + `<p class="legend-line">${none ? 'No levels recorded yet. ' : ''}A level moves only when a check proves the fix.</p></div>`;
 }
 /**
@@ -500,10 +508,48 @@ export function developersTableHtml(register) {
         const said = col === provenAt ? fromFile.get(lane.id) ?? 0 : 0;
         return `<td>${n(v)}${said ? ` (${n(said)} ${FROM_FILE})` : ''}</td>`;
     };
-    const head = t.header.map((h) => `<th scope="col">${esc(h)}</th>`).join('');
+    // Spec 2026-10-06 §9 item 7: how far each lane is, what it does next (the
+    // first three by effective priority) and how much recorded work sits outside
+    // the focus — a plain count, recorded and never blocked.
+    const nameOf = new Map(register.objects.map((o) => [o.key, o.name]));
+    const plan = (lane) => {
+        // A key with no object behind it names nothing a reader can find, so it is
+        // left out rather than printed as the raw key.
+        const keys = (lane.next ?? []).slice(0, 3);
+        const next = keys.map((k) => nameOf.get(k)).filter((name) => name);
+        return `<td>${n(lane.donePct ?? 0)}%</td>`
+            + `<td class="next">${keys.length ? next.map((name) => `<span class="ident">${cell(name)}</span>`).join(', ') : '<span class="quiet-note">nothing open</span>'}</td>`
+            + `<td>${n(lane.outsideFocus ?? 0)}</td>`;
+    };
+    const head = [...t.header, 'Done %', 'Next', 'Outside the focus'].map((h) => `<th scope="col">${esc(h)}</th>`).join('');
     const body = t.rows.map((r, i) => `<tr><td>${cell(r[0])}</td>${r.slice(1, -1).map((v, j) => num(v, j + 1, register.lanes[i])).join('')}`
-        + `<td>${esc(formatWhen(register.lanes[i].lastRecordAt))}</td></tr>`).join('');
+        + `<td>${esc(formatWhen(register.lanes[i].lastRecordAt))}</td>${plan(register.lanes[i])}</tr>`).join('');
     const note = overlapNote(register);
     return `<div class="scroller"><table><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table></div>`
         + (note ? `<p class="quiet-note">${esc(note)}</p>` : '');
 }
+/* ── The focus, under the headline (spec 2026-10-06 §9 item 1) ──────────── */
+const MONTH_WORDS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/** A day as a person says it: 24 Sep 2026. UTC, like every time on this page. */
+export const dayWords = (iso) => {
+    const t = iso ? new Date(iso) : null;
+    return !t || Number.isNaN(t.getTime()) ? '' : `${t.getUTCDate()} ${MONTH_WORDS[t.getUTCMonth()]} ${t.getUTCFullYear()}`;
+};
+export const NO_FOCUS = 'No focus set. Working lists follow the suggested order.';
+/**
+ * The second line of the headline: the focus on top of the stack — what, who
+ * set it and when, why, and how much of it is done — or the sentence that says
+ * there is none. Escaped markup.
+ */
+export function focusLineHtml(register) {
+    const f = register?.plan?.focuses?.[0];
+    if (!f)
+        return esc(NO_FOCUS);
+    const day = dayWords(f.at);
+    return [
+        `Now: ${cell(f.label)}`,
+        `set by ${cell(f.by)}${day ? ` ${esc(day)}` : ''}`,
+        ...(f.reason ? [`because ${cell(f.reason)}`] : []),
+        `${n(f.donePct ?? 0)}% done`,
+    ].join(' · ');
+}

package/dist/register/status-file/register-status-file.js

@@ -34,12 +34,9 @@
  */
 import { esc } from './register-map.js';
 import { formatWhen } from './register-model.js';
-// Every mark this file shares with the page. One copy, in a module that knows
-// nothing about the browser: two pictures of one folder that disagree would be
-// worse than no picture at all, and these two had already begun to.
-import { decisionWord, developersTableHtml, dispositionsHtml, ignoredRunsHtml, mapBodyHtml, measuredWord, n, needItemHtml, notMeasuredLine, ownerLabel, provenanceLine, readNote, runsTableHtml, stateWord, whereItStandsHtml, } from './register-parts.js';
+import { n, provenanceLine, readNote } from './register-parts.js';
+import { FIX_RULE, LEVEL_KEY, NO_TARGET_LINE, READING_LINE, awaitingWord, dayWords, lastCheckWord, reportView, trendLine, } from './report-model.js';
 const FILE_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:";
-const objects = (count) => `${n(count)} object${count === 1 ? '' : 's'}`;
 const files = (count) => `${n(count)} file${count === 1 ? '' : 's'}`;
 /**
  * What the file is called once it lands in somebody's downloads. A manager with
@@ -54,118 +51,137 @@ export function statusFileName(project, asOf) {
     const slug = String(project?.name ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'team-project';
     return `${slug}-status-${String(asOf).slice(0, 10)}.html`;
 }
-/**
- * One package, folded shut. The count is in the fold's own line so the size of
- * a package is readable without opening it — a real project puts thousands of
- * rows behind one of these.
- */
-function packageFold(block, lanes, runs, projectType) {
-    // An empty cell reads as a value somebody lost rather than as one nobody has
-    // set yet, so both absences say themselves in words — in the same lower case
-    // as the values they stand in for ("fix", "retire", a person's name).
-    //
-    // The last column is the whole of step 2 in one cell: what the system found,
-    // or that nobody has looked. A reader working down this list must not have to
-    // take a colour on trust, and "not measured" is an answer, not a blank.
-    const row = (o) => `<tr><td class="ident">${esc(o.name)}</td><td>${esc(o.type)}</td><td>${esc(stateWord(o))}</td>`
-        + `<td>${esc(decisionWord(o.decision, projectType))}</td>`
-        + `<td>${esc(ownerLabel(lanes.find((l) => l.id === o.lane)))}</td>`
-        + `<td>${esc(measuredWord(o, runs))}</td></tr>`;
-    // Every fold holds a table with the same six headings, so each one says
-    // which package it belongs to — otherwise a screen reader announces the
-    // twelfth "Object, Type, State, Decision, Owner, Measured" with nothing to
-    // tell it from the eleventh.
-    return `<details data-role="package"><summary>${esc(block.package)} — ${objects(block.objects.length)}</summary>`
-        + `<div class="scroller"><table aria-label="${esc(block.package)}"><thead><tr><th scope="col">Object</th><th scope="col">Type</th>`
-        + '<th scope="col">State</th><th scope="col">Decision</th><th scope="col">Owner</th><th scope="col">Measured</th></tr></thead>'
-        + `<tbody>${block.objects.map(row).join('')}</tbody></table></div></details>`;
-}
 /** Nothing in a saved file can reload, so the page's advice is not repeated here. */
-const UNREADABLE_DETAIL = 'Some results may be missing. The next status file will include them once the files have finished syncing.';
+const LANE_CAP = 8;
+const KEPT_CAP = 10;
+const numbersHtml = (view) => `<ul class="rp-numbers" data-role="numbers">${view.numbers.map((x) => `<li data-num="${esc(x.id)}">`
+    + `<span class="rp-n">${n(x.n)}</span><span class="rp-label">${esc(x.label)}</span><span class="rp-sub">${esc(x.sub)}</span></li>`).join('')}</ul>`;
+function levelsHtml(view) {
+    const rows = view.levels.map((l) => `<li><span class="rp-lv">${esc(l.word)}</span><span class="rp-lv-n">${n(l.n)}</span>`
+        + `<span class="rp-lv-key">${esc(l.key)}</span></li>`).join('');
+    const t = view.target;
+    const target = t.set
+        ? `<p class="rp-target" data-role="target">${esc(t.line)}${t.keptLine ? ` ${esc(t.keptLine)}` : ''}</p>`
+            + `${(t.provenLines ?? []).map((l) => `<p class="rp-target" data-role="proven-for-target">${esc(l)}</p>`).join('')}<p class="rp-note">${esc(READING_LINE)}</p>`
+        : `<p class="rp-target" data-role="target">${esc(NO_TARGET_LINE)}</p>`;
+    return `<section class="rp-levels" data-role="levels"><h2>Objects by clean-core level, now</h2><ul class="rp-lvs">${rows}</ul>${target}</section>`;
+}
+function decisionsHtml(view) {
+    const d = view.decisions;
+    const list = d.total
+        ? `<ol>${d.shown.map((x) => `<li><p>${esc(x.text)}</p><p class="rp-who">Decides: ${esc(x.decides)}.${x.since ? ` Since ${esc(dayWords(x.since))}.` : ''}</p></li>`).join('')}</ol>`
+            + (d.more ? `<p class="rp-tail">And ${n(d.more)} more in the workbook.</p>` : '')
+        : '<p>Nothing is waiting for a decision.</p>';
+    return `<section class="rp-decide" data-role="decisions"><h2>Decisions needed: ${d.total ? n(d.total) : 'none'}</h2>${list}</section>`;
+}
+function changedHtml(view) {
+    const c = view.changed;
+    if (c.first)
+        return `<section class="rp-changed" data-role="changed"><h2>Changed since the last report</h2><p>${esc(c.line)}</p></section>`;
+    return `<section class="rp-changed" data-role="changed"><h2>Changed since the last report, ${esc(dayWords(c.since))}</h2>`
+        + (c.line ? `<p>${esc(c.line)}</p>` : '')
+        + (c.lines.length ? `<ul>${c.lines.map((l) => `<li>${esc(l)}</li>`).join('')}</ul>` : '')
+        + (c.more ? '<p class="rp-tail">The ones left out are in History.</p>' : '')
+        + (c.moreObjects ? `<p class="rp-tail">The rest of the objects a check proved or failed are on the Objects sheet.</p>` : '')
+        + '</section>';
+}
+const LANE_HEAD = ['Lane packages', 'Objects', 'Decided', 'Fixes proven', 'Awaiting check', 'Kept', 'Rebuilds', 'Fix failed', 'Last check'];
+function lanesHtml(view) {
+    const rows = view.lanes.slice(0, LANE_CAP).map((r) => `<tr><th scope="row">${esc(r.developer)}</th>`
+        + `<td data-l="Lane packages" class="rp-pk">${esc(r.packagesWord)}</td><td data-l="Objects">${n(r.objects)}</td><td data-l="Decided">${n(r.decided)}</td>`
+        + `<td data-l="Fixes proven">${n(r.fixesProven)}</td><td data-l="Awaiting check">${esc(awaitingWord(r))}</td><td data-l="Kept">${n(r.kept)}</td>`
+        + `<td data-l="Rebuilds">${n(r.rebuilds)}</td><td data-l="Fix failed">${n(r.fixFailed)}</td><td data-l="Last check">${esc(lastCheckWord(r))}</td></tr>`).join('');
+    const more = view.lanes.length > LANE_CAP ? `<p class="rp-tail">And ${n(view.lanes.length - LANE_CAP)} more on the workbook's Summary sheet.</p>` : '';
+    return '<section class="rp-detail" data-role="lanes"><h2>By lane / developer</h2>'
+        + `<div class="scroller"><table class="rp-devs" aria-label="By lane / developer"><thead><tr><th scope="col">Developer</th>${LANE_HEAD.map((h) => `<th scope="col">${h}</th>`).join('')}</tr></thead>`
+        + `<tbody>${rows}</tbody></table></div>${more}`
+        + "<p class=\"rp-tail\">Lanes are listed in the order they were set up, never ranked. On the workbook's Objects sheet, filter Lane to see one developer's list.</p></section>";
+}
+function keptHtml(view) {
+    const k = view.kept;
+    const body = k.length
+        ? `<ul class="rp-kept-list">${k.slice(0, KEPT_CAP).map((x) => `<li><p>${esc(x.line)}</p>${x.why ? `<p class="rp-why">${esc(x.why)}</p>` : ''}<p class="rp-why">${esc(x.by)}</p></li>`).join('')}</ul>`
+            + (k.length > KEPT_CAP ? `<p class="rp-tail">And ${n(k.length - KEPT_CAP)} more on the workbook's For the business sheet.</p>` : '')
+        : '<p>No object is kept by decision.</p>';
+    return `<section class="rp-kept" data-role="kept"><h2>Kept as is, by decision (${n(k.length)})</h2>${body}</section>`;
+}
+function rebuildsHtml(view) {
+    const g = view.rebuilds;
+    if (!g.total)
+        return '';
+    return `<section class="rp-rebuilds" data-role="rebuilds"><h2>Rebuilds (${n(g.total)})</h2><p>${esc(g.words.join(' · '))}.</p>`
+        + (g.staleLines.length ? `<ul>${g.staleLines.map((l) => `<li>${esc(l)}</li>`).join('')}</ul>` : '')
+        + '</section>';
+}
 /**
- * The whole document.
+ * The whole document: the one report.
  *
- * Read in the order a manager reads it: whose team project, when this was true, the
- * one line, the picture, what is waiting for a person, who owns what — and only
- * then, folded away, every object one by one.
+ * Page 1, in order: the coverage line (with the check and its date) · the
+ * headline and scope · five numbers (six with rebuilds) · levels now ·
+ * decisions needed · changed since the last report. Page 2: by lane /
+ * developer, the kept-by-decision list, the rebuild group.
  *
- * `css` is the only value written in unescaped, and the only one that never came
- * out of the folder: it is our own stylesheet, imported at build time. Every
- * name, package, decision and person below goes through `esc()`.
+ * `previousAsOf` is the as-of stamp of the status page this one replaces (read
+ * from its `cspeach-as-of` meta tag before it is overwritten); null for the
+ * first report. `summary`, `needs` and `blocks` are still accepted from the
+ * page's `collectView` and not drawn: the one report works its numbers out
+ * from the same folder, once, in report-model.js.
+ *
+ * `estate` is the discovery file as the folder read it: given but not read into
+ * the picture, the scope sentence says it could not be read, never "none".
  *
- * `files`, `checksum` and `register.skipped` are what the read note is worked
- * out from. The file prints it for the same reason the page does, and with more
- * reason: whoever this was mailed to cannot look in the folder to find out that
- * a ruling was ignored, and an ignored ruling is a decision somebody made that
- * this picture does not show.
+ * `css` is the only value written in unescaped, and the only one that never came
+ * out of the folder. Every name, package, decision and person goes through `esc()`.
  *
- * @param {{ project: object, register: object, summary: object, needs: object[],
- *           blocks: object[], css: string, asOf: string, folderName: string,
- *           files?: number, checksum?: string, unreadable?: number }} view
+ * @param {{ project: object, register: object, css: string, asOf: string, folderName: string,
+ *           files?: number, checksum?: string, unreadable?: number, needs?: object[], previousAsOf?: string|null,
+ *           estate?: unknown }} view
  * @returns {string}
  */
-export function buildStatusHtml({ project, register, summary, needs, blocks, css, asOf, folderName, files: filesRead = 0, checksum, unreadable = 0, }) {
-    // A file with no time on it, or with the wrong one, is worse than no file:
-    // somebody will act on it. Refuse rather than print "never" or quietly stamp
-    // the moment Save was pressed.
+export function buildStatusHtml({ project, register, needs = [], css, asOf, folderName, files: filesRead = 0, checksum, unreadable = 0, previousAsOf = null, estate = undefined, }) {
+    // A file with no time on it is worse than no file: somebody will act on it.
     if (!asOf)
         throw new Error('buildStatusHtml needs asOf — the time the folder was read. The file states it as the truth of the picture.');
-    // The file says how many files were missing. A caller that reports the need
-    // but not the count would have it say "0 files could not be read", which is
-    // the opposite of what the need means.
+    // "0 files could not be read" would be the opposite of what the need means.
     if (needs?.some((i) => i.kind === 'unreadable') && !(Number.isFinite(unreadable) && unreadable > 0)) {
         throw new Error('buildStatusHtml needs unreadable — a need says files could not be read, and the file states how many.');
     }
-    // `css` is ours, but this function is exported and pure, so a caller could one
-    // day hand it something with a closing style tag in it, which would end the
-    // stylesheet early and put the rest of it into the document as text — or as
-    // markup. Refuse; do not rewrite it behind the caller's back.
+    // A closing style tag would end the stylesheet early. Refuse; never rewrite it.
     if (/<\/style/i.test(css))
         throw new Error('buildStatusHtml refuses css that closes the style element.');
-    // "Reload in a minute" is true on the page and false in a file that cannot
-    // reload. The page keeps the model's wording; the file says what a reader
-    // holding a snapshot can actually expect. This is the ONE mark where the two
-    // surfaces are allowed to differ.
-    const forFile = (i) => (i.kind !== 'unreadable' ? i
-        : { ...i, title: `${files(unreadable)} could not be read when this was made`, detail: UNREADABLE_DETAIL });
+    const view = reportView({ project, register, asOf, previousAsOf });
+    const trend = trendLine(view.trend);
+    const levelKey = `Levels: ${['A', 'B', 'C', 'D'].map((l) => `${l} ${LEVEL_KEY[l]}`).join('; ')}. ${FIX_RULE}`;
     return `<!doctype html>
 <html lang="en"><head><meta charset="utf-8">
 <meta http-equiv="Content-Security-Policy" content="${FILE_CSP}">
 <meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="cspeach-as-of" content="${esc(asOf)}">
 <title>${esc(project.name)} — status as of ${esc(String(asOf).slice(0, 10))}</title>
 <style>${css}</style></head>
-<body><main id="app">
+<body><main id="app" class="rp">
 <header class="masthead">
 <p class="provenance">${provenanceLine(project)}</p>
 <h1>${esc(project.name)}</h1>
 <p class="stamp" data-role="stamp">Status as of ${esc(formatWhen(asOf))}. This file does not update. Made by CSPeach from the folder ${esc(folderName)}.</p>
 ${unreadable > 0 ? `<p class="notice" data-role="incomplete">${files(unreadable)} could not be read, so this picture may be incomplete.</p>` : ''}
-<p class="summary" data-role="summary">${esc(summary.line)}</p>
-${notMeasuredLine(register) ? `<p class="unmeasured" data-role="not-measured">${esc(notMeasuredLine(register))}</p>` : ''}
 </header>
-<section class="stands" data-role="stands"><h2>Where it stands</h2>
-${whereItStandsHtml(register)}
-</section>
-<section class="dispositions"><h2>Decisions</h2>
-${dispositionsHtml(register)}
-</section>
-<section class="needs" data-role="needs"><h2>Needs you</h2>
-${needs.length ? `<ul>${needs.map(forFile).map(needItemHtml).join('')}</ul>` : '<p>Nothing is waiting for anyone.</p>'}
-</section>
-<section class="lanes" data-role="lanes"><h2>Who owns what</h2>
-${developersTableHtml(register)}
-</section>
-<section class="map"><h2>Every object</h2>
-${mapBodyHtml(register, blocks, { role: 'img' })}
-</section>
-<section class="runs" data-role="runs"><h2>Measurements</h2>
-${runsTableHtml(register.runs)}
-${ignoredRunsHtml(register.ignoredRuns)}
-</section>
-<section class="objects"><h2>The object list</h2>
-${blocks.map((b) => packageFold(b, register.lanes, register.runs, project.type)).join('')}
-</section>
-<footer><p data-role="read-note">${esc(readNote({ files: filesRead, unreadable, checksum, register }, { tense: 'past' }))}</p>
+<div class="rp-first">
+<div class="rp-coverage"><p class="rp-coverage-line" data-role="coverage">${esc(view.coverage.line)}</p>${trend ? `<p class="rp-trend" data-role="trend">${esc(trend)}</p>` : ''}${view.coverage.notes.map((note) => `<p class="rp-trend" data-role="coverage-note">${esc(note)}</p>`).join('')}</div>
+<p class="rp-headline" data-role="headline">${esc(view.headline)}</p>
+<p class="rp-scope" data-role="scope">${esc(view.scope)}${estate !== undefined && !register.estate ? ' The estate inventory in this folder could not be read.' : ''}</p>
+${numbersHtml(view)}
+<div class="rp-band">
+${levelsHtml(view)}
+${decisionsHtml(view)}
+</div>
+${changedHtml(view)}
+</div>
+${lanesHtml(view)}
+${keptHtml(view)}
+${rebuildsHtml(view)}
+<footer><p class="rp-key">${esc(levelKey)}</p>
+<p data-role="read-note">${esc(`${readNote({ files: filesRead, unreadable, checksum, register }, { tense: 'past' })}`.replace(/([^.])$/, '$1.'))}</p>
 <p data-role="trust">This file holds object names, packages, team member names, decisions, fix status and check results. No source code. No passwords. It contains no script and no links, and it cannot load anything from the internet.</p></footer>
 </main></body></html>`;
 }