@cspeach/cli 1.1.31 → 1.1.32

package/dist/register/rules-edit.js

@@ -0,0 +1,257 @@
+/**
+ * The decision-rule edits behind `/rules` and `cspeach team rules` (step 2,
+ * Task 10; spec 2026-10-08 §7 D7).
+ *
+ * Pure: every edit takes the rules as they are and gives back the new list,
+ * the one line said about it (History, the printed line) and the confirm card's
+ * question. Each result is read back through register-core's strict reader, so
+ * nothing this file makes could be refused by the next read. `null` rules mean
+ * "restore the defaults": the file then names no rules at all.
+ */
+import { readDecisionRules, levelOf, } from '@cspeach/register-core';
+import { RegisterError } from './store.js';
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const DISPOSITIONS = ['keep', 'fix', 'rebuild', 'retire-candidate'];
+/* ── plain words ─────────────────────────────────────────────────────────── */
+const TYPE_WORDS = {
+    PROG: 'program', CLAS: 'class', INTF: 'interface', FUGR: 'function group', DDLS: 'CDS view', TABL: 'table', ENHO: 'enhancement',
+};
+const CLASS_WORDS = {
+    'not-released': 'unreleased APIs', 'not-to-be-released': 'APIs SAP will not release', deprecated: 'deprecated APIs',
+    'cloud-language': 'statements ABAP Cloud does not allow', quality: 'quality findings (for example ORDER BY or WRITE in a loop)', modification: 'modifications', unclassified: 'unclassified findings',
+};
+/** Finding-rule prefixes with plain words; any other is said by its id. */
+const RULE_WORDS = { SEARCH_PROBLEMATIC_STATEMENTS_FOR_ALV_CALLS: 'ALV list output' };
+const DISPOSITION_WORDS = { keep: 'keep', fix: 'fix', rebuild: 'rebuild', 'retire-candidate': 'retire candidate' };
+const or = (words) => (words.length <= 1 ? words.join('') : `${words.slice(0, -1).join(', ')} or ${words.at(-1)}`);
+const cap = (s) => (s ? s[0].toUpperCase() + s.slice(1) : s);
+/** "more than 25 findings", "10 or fewer findings", "3 to 10 findings"; null when the rule counts nothing. */
+export function countWords(w) {
+    const min = w.minFindings;
+    const max = w.maxFindings;
+    if (min === undefined && max === undefined)
+        return null;
+    if (min !== undefined && max !== undefined)
+        return `${min} to ${max} findings`;
+    if (min !== undefined)
+        return min === 0 ? '0 or more findings' : `more than ${min - 1} findings`;
+    return `${max} or fewer findings`;
+}
+/** One phrase per condition. `first` = it follows the subject directly ("Any object with …"). */
+function phrases(w) {
+    const out = [];
+    const both = (s) => out.push({ first: s, next: s });
+    const known = new Set(['types', 'minFindings', 'maxFindings']);
+    // The order a lead reads them in; any key not named here follows by its own name.
+    const said = [
+        ['noOpenForTarget', () => both('that meets its target already')],
+        ['findingClasses', () => both(`with ${or(w.findingClasses.map((c) => CLASS_WORDS[c] ?? c))}`)],
+        ['onlyClasses', () => both(`with only ${or(w.onlyClasses.map((c) => CLASS_WORDS[c] ?? c))}`)],
+        ['findingRules', () => both(`with ${or(w.findingRules.map((r) => RULE_WORDS[r] ?? `findings of ${r}`))}`)],
+        ['levelNow', () => both(`now at level ${or(w.levelNow)}`)],
+        ['targetAtMost', () => out.push({ first: `with target ${w.targetAtMost} or stricter`, next: `target ${w.targetAtMost} or stricter` })],
+        ['callers', () => both('with no callers found')],
+        ['usage', () => both('with usage read as unused')],
+    ];
+    for (const [key, say] of said) {
+        known.add(key);
+        if (w[key] !== undefined)
+            say();
+    }
+    const counted = countWords(w);
+    if (counted)
+        out.push({ first: `with ${counted}`, next: counted });
+    for (const [key, v] of Object.entries(w)) {
+        if (known.has(key) || v === undefined)
+            continue;
+        // A condition this build has no words for is said by its name, never dropped.
+        const values = Array.isArray(v) ? v.map(String) : [String(v)];
+        both(`${key} ${or(values)}`);
+    }
+    return out;
+}
+/** The "when" half: "Program with ALV list output, target A or stricter". */
+export function whenWords(w) {
+    const types = w.types?.length ? w.types.map((t) => TYPE_WORDS[t] ?? t) : null;
+    const subject = types ? cap(or(types)) : 'Any object';
+    const ps = phrases(w);
+    if (!ps.length)
+        return subject;
+    return `${subject} ${ps[0].first}${ps.slice(1).map((p) => `, ${p.next}`).join('')}`;
+}
+/** The "then" half: "rebuild", "rebuild, target B". */
+export function thenWords(t) {
+    return `${DISPOSITION_WORDS[t.disposition] ?? t.disposition}${t.target ? `, target ${t.target}` : ''}`;
+}
+/** One rule in plain words: "Program with ALV list output, target A or stricter → rebuild". */
+export const ruleWords = (r) => `${whenWords(r.when)} → ${thenWords(r.then)}`;
+const dayMonth = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? '' : `${d.getUTCDate()} ${MONTHS[d.getUTCMonth()]}`;
+};
+const changedWords = (r) => (r.changedBy ? `${r.changedBy}${r.changedAt && dayMonth(r.changedAt) ? ` on ${dayMonth(r.changedAt)}` : ''}` : 'default');
+/** The numbered table: id · when → then · on/off · last changed by. */
+export function rulesTableLines(rules, from, warning) {
+    const head = from === 'default'
+        ? 'Decision rules — the defaults (cspeach-team.json names none).'
+        : 'Decision rules — from cspeach-team.json.';
+    return [
+        `${head} The first rule that is on and holds decides; a person confirms every row.`,
+        ...(warning ? [`  ${warning}`] : []),
+        ...rules.map((r, i) => `${i + 1}. ${r.id} · ${ruleWords(r)} · ${r.on ? 'on' : 'off'} · ${changedWords(r)}`),
+    ];
+}
+/* ── the edits ───────────────────────────────────────────────────────────── */
+const copy = (v) => JSON.parse(JSON.stringify(v));
+function find(rules, id) {
+    const i = rules.findIndex((r) => r.id.toUpperCase() === id.trim().toUpperCase());
+    if (i < 0)
+        throw new RegisterError(`There is no rule ${id.trim() || '(none given)'}. Rules: ${rules.map((r) => r.id).join(', ') || 'none'}.`);
+    return i;
+}
+/** The list as the next read will see it; anything the strict reader refuses is refused here, in its words. */
+function checked(rules) {
+    const read = readDecisionRules({ decisionRules: rules });
+    if (read.warning) {
+        const why = /\((.*)\)/.exec(read.warning)?.[1] ?? read.warning;
+        throw new RegisterError(`That change cannot be saved: ${why}.`);
+    }
+    return read.rules;
+}
+function replaced(rules, i, next, stamp) {
+    const out = copy(rules);
+    out[i] = { ...next, changedBy: stamp.by, changedAt: stamp.at };
+    return checked(out);
+}
+export function toggleRule(rules, id, on, stamp) {
+    const i = find(rules, id);
+    const before = rules[i];
+    if (before.on === on)
+        throw new RegisterError(`Rule ${before.id} is already ${on ? 'on' : 'off'}.`);
+    const next = replaced(rules, i, { ...copy(before), on }, stamp);
+    const words = ruleWords(before);
+    return {
+        rules: next, basis: copy(rules), change: on ? 'on' : 'off', id: before.id, before: copy(before), after: next[i],
+        summary: `Rule ${before.id} turned ${on ? 'on' : 'off'}: ${words}`,
+        card: `Turn ${on ? 'on' : 'off'} rule ${before.id}: ${words}.`,
+    };
+}
+/** A count from a flag or a typed answer: a whole number of 0 or more, else the one sentence. */
+export function wholeCount(v, flag) {
+    const n = typeof v === 'number' ? v : typeof v === 'string' && /^\s*\d+\s*$/.test(v) ? Number(v) : Number.NaN;
+    if (!Number.isInteger(n) || n < 0)
+        throw new RegisterError(`${flag} needs a whole number of 0 or more, for example ${flag} 15.`);
+    return n;
+}
+export function setThreshold(rules, id, t, stamp) {
+    const i = find(rules, id);
+    const before = rules[i];
+    const when = { ...copy(before.when) };
+    if (t.minFindings !== undefined)
+        when.minFindings = wholeCount(t.minFindings, '--min-findings');
+    if (t.maxFindings !== undefined)
+        when.maxFindings = wholeCount(t.maxFindings, '--max-findings');
+    if (when.minFindings !== undefined && when.maxFindings !== undefined && when.minFindings > when.maxFindings) {
+        throw new RegisterError(`That would need at least ${when.minFindings} and at most ${when.maxFindings} findings: no object could match.`);
+    }
+    const next = replaced(rules, i, { ...copy(before), when }, stamp);
+    const was = countWords(before.when);
+    const now = countWords(when);
+    const change = was ? `${was.replace(/ findings$/, now.endsWith(' findings') ? '' : ' findings')} → ${now}` : `${now} (was no count)`;
+    const said = `rule ${before.id}: ${change} → ${thenWords(before.then)}`;
+    return { rules: next, basis: copy(rules), change: 'set', id: before.id, before: copy(before), after: next[i], summary: cap(said), card: `Change ${said}.` };
+}
+export function setOutcome(rules, id, disposition, stamp, target) {
+    if (!DISPOSITIONS.includes(disposition))
+        throw new RegisterError('--then is keep, fix, rebuild or retire-candidate.');
+    const i = find(rules, id);
+    const before = rules[i];
+    const then = { disposition };
+    const t = target === undefined ? before.then.target : target === null ? undefined : levelOrThrow(target);
+    if (t)
+        then.target = t;
+    const next = replaced(rules, i, { ...copy(before), then }, stamp);
+    const said = `rule ${before.id}: ${thenWords(before.then)} → ${thenWords(then)} (${whenWords(before.when)})`;
+    return { rules: next, basis: copy(rules), change: 'set', id: before.id, before: copy(before), after: next[i], summary: cap(said), card: `Change ${said}.` };
+}
+function levelOrThrow(v) {
+    const l = levelOf(v);
+    if (!l)
+        throw new RegisterError('--target is A, B, C or D.');
+    return l;
+}
+/** The level the rule proposes; null = the object's own target (the default). */
+export function setTarget(rules, id, target, stamp) {
+    const t = target === null ? null : levelOrThrow(target);
+    const i = find(rules, id);
+    const before = rules[i];
+    const then = { disposition: before.then.disposition, ...(t ? { target: t } : {}) };
+    const next = replaced(rules, i, { ...copy(before), then }, stamp);
+    const own = "the object's own target";
+    const said = `rule ${before.id} target: ${before.then.target ?? own} → ${t ?? own}`;
+    return { rules: next, basis: copy(rules), change: 'set', id: before.id, before: copy(before), after: next[i], summary: cap(said), card: `Change ${said}.` };
+}
+/** The rules a lead can add by name. Each is checked by the strict reader like any other. */
+export const RULE_TEMPLATES = {
+    'many-findings': { when: { minFindings: 26 }, then: { disposition: 'rebuild' }, note: 'too many findings to fix in place' },
+    'few-findings': { when: { maxFindings: 5 }, then: { disposition: 'fix' }, note: 'few findings: fix in place' },
+    'meets-target': { when: { noOpenForTarget: true }, then: { disposition: 'keep' }, note: 'meets its target already' },
+    'no-callers': { when: { callers: 'none-read-ok', usage: 'unused' }, then: { disposition: 'retire-candidate' }, note: 'no callers found; candidate until the lead confirms' },
+    'unreleased-class': {
+        when: { types: ['CLAS', 'INTF'], onlyClasses: ['not-released', 'deprecated'], maxFindings: 10 },
+        then: { disposition: 'fix' }, note: 'a small class using unreleased or deprecated APIs: swap to released ones',
+    },
+    'classic-program': {
+        when: { types: ['PROG'], findingRules: ['SEARCH_PROBLEMATIC_STATEMENTS_FOR_ALV_CALLS'], targetAtMost: 'A' }, then: { disposition: 'rebuild' }, note: 'a classic list program cannot reach A in place',
+    },
+};
+/** The next free "R<n>" after the highest one in use. */
+function nextId(rules) {
+    const n = Math.max(0, ...rules.map((r) => Number(/^R(\d+)$/i.exec(r.id)?.[1] ?? 0)));
+    return `R${n + 1}`;
+}
+/** Added at the end: rules are tried in order, so a new one never jumps ahead of the lead's own. */
+export function addFromTemplate(rules, template, stamp) {
+    const t = RULE_TEMPLATES[template.trim().toLowerCase()];
+    if (!t)
+        throw new RegisterError(`There is no template "${template.trim()}". Templates: ${Object.keys(RULE_TEMPLATES).join(', ')}.`);
+    const rule = { id: nextId(rules), on: true, ...copy(t), changedBy: stamp.by, changedAt: stamp.at };
+    const next = checked([...copy(rules), rule]);
+    const said = `rule ${rule.id} added from the template ${template.trim().toLowerCase()}: ${ruleWords(rule)}`;
+    return { rules: next, basis: copy(rules), change: 'add', id: rule.id, before: null, after: next.at(-1), summary: cap(said), card: `Add ${said.replace(' added', '')}.` };
+}
+export function removeRule(rules, id) {
+    const i = find(rules, id);
+    const before = rules[i];
+    const next = checked(copy(rules).filter((_, k) => k !== i));
+    return {
+        rules: next, basis: copy(rules), change: 'remove', id: before.id, before: copy(before), after: null,
+        summary: `Rule ${before.id} removed: ${ruleWords(before)}`, card: `Remove rule ${before.id}: ${ruleWords(before)}.`,
+    };
+}
+export function resetRules(basis) {
+    return {
+        rules: null, ...(basis ? { basis: copy(basis) } : {}), change: 'reset', before: null, after: null,
+        summary: 'Decision rules restored to the defaults',
+        card: 'Restore the default decision rules? Every change made to the rules is replaced.',
+    };
+}
+/**
+ * A rule from the person's words (the model's `rules_propose`): the proposal
+ * is data, never trusted. Its own id, on/off and stamp are ignored — the rule
+ * gets the next free id, starts on, and is stamped by the person who saves it —
+ * and the whole list must pass the strict reader. Added at the end.
+ */
+export function addProposed(rules, proposal, stamp) {
+    let candidate = proposal;
+    if (proposal && typeof proposal === 'object' && !Array.isArray(proposal)) {
+        const { id: _id, on: _on, changedBy: _by, changedAt: _at, ...rest } = proposal;
+        candidate = { id: nextId(rules), on: true, ...rest, changedBy: stamp.by, changedAt: stamp.at };
+    }
+    const next = checked([...copy(rules), candidate]);
+    const rule = next.at(-1);
+    return {
+        rules: next, basis: copy(rules), change: 'add', id: rule.id, before: null, after: rule,
+        summary: `Rule ${rule.id} added from your words: ${ruleWords(rule)}`, card: `Add rule ${rule.id}: ${ruleWords(rule)}.`,
+    };
+}

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

@@ -34,15 +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, focusLineHtml, notMeasuredLine, ownerLabel, provenanceLine, readNote, runsTableHtml, stateWord, whereItStandsHtml, } from './register-parts.js';
-import { estateSectionHtml } from './estate-parts.js';
-import { progressSectionHtml } from './progress-chart.js';
-import { planSectionHtml } from './plan-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
@@ -57,133 +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, o.state))}</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 and the focus, the estate (or the sentence saying there is none, or
- * that it could not be read — `estate` is the discovery file as the folder read
- * gave it, exactly as the page gets it), where it stands,
- * progress over time, what is waiting for a person, who owns what, the plan —
- * and only then, folded away, every object one by one. The same sections, in
- * the same order, as the page.
+ * 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, estate?: unknown }} 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, estate = undefined, // the default keeps it optional for the TypeScript copy
- }) {
-    // 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>
-<p class="focus-line" data-role="focus">${focusLineHtml(register)}</p>
-${notMeasuredLine(register) ? `<p class="unmeasured" data-role="not-measured">${esc(notMeasuredLine(register))}</p>` : ''}
 </header>
-<section class="estate" data-role="estate"><h2>Estate</h2>
-${estateSectionHtml(register, { fileGiven: estate !== undefined, now: asOf })}
-</section>
-<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="progress" data-role="progress"><h2>Progress over time</h2>
-${progressSectionHtml(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="plan" data-role="plan"><h2>Plan and changes</h2>
-${planSectionHtml(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>`;
 }