@cspeach/cli 1.1.31 → 1.1.32

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

@@ -0,0 +1,569 @@
+// @ts-nocheck
+// GENERATED COPY — do not edit here. Edit viewer/src/lib/report-model.js,
+// then run `npx tsx scripts/sync-status-file.ts` (prebuild runs it too).
+// src/register/__tests__/status-file-pin.test.ts fails when this copy drifts.
+/**
+ * The one report: what a manager, a lead and a developer read about one team
+ * project, all lanes together, worked out once.
+ *
+ * "We need a simple report where we see different lanes together" (owner,
+ * 2026-10-08). The saved status page, the workbook and `cspeach team status`
+ * all print from `reportView`, so a number on paper, in Excel and in the
+ * terminal cannot differ.
+ *
+ * Pure: a Register in, plain data out. No DOM and no clock — `asOf` is handed
+ * in. The honesty rules this file keeps (each pinned by a test):
+ *  - the coverage line comes first: no percentage, no claim before it;
+ *  - "fix proven" counts only objects the check moved to verified — an object
+ *    that was clean from its first check never had a fix to prove;
+ *  - kept by decision is its own count: never "not started", never "below target";
+ *  - no target anywhere → one line, "no target set — counted as the check reports",
+ *    and no judgement words;
+ *  - developers are listed in lane order (lanes.json), never by a count.
+ */
+import { PLAN_COLUMNS, inLane, isOutsideUsageWindowLine, planRows, provenForTarget, provenForTargetWords, targetsOf, usageCellOf, utcWords } from '@cspeach/register-core';
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const two = (v) => String(v).padStart(2, '0');
+const DAY_MS = 86_400_000;
+/** `8 Oct 2026 02:39 UTC`. */
+export function whenWords(iso) {
+    const t = iso ? new Date(iso) : null;
+    if (!t || Number.isNaN(t.getTime()))
+        return '';
+    return `${t.getUTCDate()} ${MONTHS[t.getUTCMonth()]} ${t.getUTCFullYear()} ${two(t.getUTCHours())}:${two(t.getUTCMinutes())} UTC`;
+}
+/** `8 Oct`. */
+export function dayWords(iso) {
+    const t = iso ? new Date(iso) : null;
+    if (!t || Number.isNaN(t.getTime()))
+        return '';
+    return `${t.getUTCDate()} ${MONTHS[t.getUTCMonth()]}`;
+}
+const count = (v) => Number(v ?? 0).toLocaleString('en-US');
+const plural = (v, one, many) => `${count(v)} ${v === 1 ? one : many}`;
+const ms = (iso) => { const t = Date.parse(iso ?? ''); return Number.isFinite(t) ? t : NaN; };
+/** The words for no target, everywhere (spec D1). */
+export const NO_TARGET = 'no target set — counted as the check reports';
+/** The same words standing alone as a sentence: on the page, the workbook and `team status`. */
+export const NO_TARGET_LINE = 'No target set — counted as the check reports.';
+/** The first report a folder gets with change tracking (review F10). Never "no changes". */
+export const FIRST_REPORT = 'First report with change tracking — changes appear from the next report.';
+/** Where the columns the workbook no longer carries went (review finding 3). */
+export const EXPORT_LINE = 'Check runs, results per object and every event are in the CSV export (cspeach team export). The system inventory is discovery/estate.xlsx.';
+/** Said once wherever a target is read against the findings. */
+export const READING_LINE = "Reading the findings against a level is CSPeach's reading of SAP's release states.";
+export const FIX_RULE = 'A fix counts when a check proves it.';
+export const LEVEL_KEY = {
+    A: 'uses only released APIs',
+    B: 'calls public classic APIs',
+    C: 'uses SAP-internal objects',
+    D: 'modifies SAP standard',
+    none: 'no person has judged its level yet',
+    nothing: 'checked clean, so nothing to decide',
+};
+/** The as-of stamp a status page carries, or null for none (a 1.1.31 page, or none at all). */
+export function asOfFromStatusHtml(text) {
+    // `[m]`: the source scan allows a meta tag only in the status file itself.
+    const m = /<[m]eta name="cspeach-as-of" content="([^"]{10,40})">/.exec(String(text ?? ''));
+    return m && Number.isFinite(Date.parse(m[1])) ? m[1] : null;
+}
+const isActive = (o) => o.inScope !== false && o.state !== 'retired';
+const classOf = (o) => o.decision?.classification;
+const isKept = (o) => classOf(o) === 'keep';
+const isRebuild = (o) => classOf(o) === 'redesign';
+const ownerOf = (register, o) => register.lanes.find((l) => l.id === o.lane)?.owner ?? null;
+const REBUILD_STATUSES = new Set(['handed-off', 'started', 'built', 'proven']);
+/** The rebuild row on an old object, read tolerantly: a later build defines it (T5). */
+const rebuildOf = (o) => {
+    const r = o.evidence?.rebuild;
+    return r && typeof r === 'object' && REBUILD_STATUSES.has(r.status) ? r : null;
+};
+/** The variant the numbers come from: the project's, else the newest counted run's. */
+function variantOf(project, register) {
+    const own = typeof project?.atcVariant === 'string' ? project.atcVariant.trim() : '';
+    if (own)
+        return own;
+    const run = [...(register.runs ?? [])].reverse().find((r) => r.atcVariant);
+    return run?.atcVariant ?? "the team project's check";
+}
+function coverageOf(project, register) {
+    const active = register.objects.filter(isActive);
+    const of = active.length;
+    const checked = active.filter((o) => (o.lastMeasuredAt ?? null) !== null).length;
+    const notChecked = of - checked;
+    const variant = variantOf(project, register);
+    const at = register.lastMeasuredAt ?? null;
+    const lastRun = [...(register.runs ?? [])].reverse().find((r) => r.at === at);
+    const fromFile = lastRun?.basis === 'file';
+    const notRun = lastRun?.coverage?.notRun ?? 0;
+    const cut = notChecked > 0 && notRun > 0 ? ` (the last check run stopped before reaching ${count(Math.min(notRun, notChecked))} of them)` : '';
+    const line = at
+        ? `Checked ${count(checked)} of ${plural(of, 'object', 'objects')} with ${variant}, latest check on ${whenWords(at)}${fromFile ? ', from a file' : ''} · ${count(notChecked)} not checked${cut}.`
+        : `Checked 0 of ${plural(of, 'object', 'objects')} with ${variant} · ${count(of)} not checked.`;
+    // What a reader two forwards away cannot look up in the folder: where the
+    // results came from, and what was left out.
+    const notes = [];
+    const runs = register.runs ?? [];
+    const fileRuns = runs.filter((r) => r.basis === 'file').length;
+    if (fileRuns)
+        notes.push(`${plural(fileRuns, 'check run was', 'check runs were')} read from a file, not run on the system.`);
+    if (runs.some((r) => r.absentMeansClean))
+        notes.push('The person who imported a file told CSPeach that objects the file does not mention are clean.');
+    const other = register.skipped?.measurementsOtherVariant ?? 0;
+    if (other)
+        notes.push(`${plural(other, 'check run made with another check variant was', 'check runs made with another check variant were')} set aside.`);
+    return { checked, of, notChecked, variant, at, fromFile, line, notes };
+}
+/**
+ * Findings in the check at each check run: each object counts its latest
+ * counted check at or before that run. The last six points.
+ */
+export function findingsTrend(register) {
+    const runs = register.runs ?? [];
+    const times = [...new Set(runs.map((r) => r.at))].filter((t) => Number.isFinite(ms(t))).sort((a, b) => ms(a) - ms(b));
+    const objects = register.objects.filter(isActive);
+    return times.slice(-6).map((t) => {
+        let sum = 0;
+        for (const o of objects) {
+            let open = null;
+            for (const m of o.measurements ?? []) {
+                if (!m.counted)
+                    continue;
+                const at = runs[m.run]?.at;
+                if (at && ms(at) <= ms(t))
+                    open = m.open;
+            }
+            sum += open ?? 0;
+        }
+        return { at: t, findings: sum };
+    });
+}
+/** Does any target exist that a person set? (controller ruling for T3/T4). */
+export function hasTarget(project, register) {
+    if (targetsOf(project).length)
+        return true;
+    return register.objects.some((o) => (classOf(o) === 'fix' || classOf(o) === 'redesign') && o.decision?.targetBy && o.decision?.targetLevel);
+}
+function targetOf(project, register) {
+    if (!hasTarget(project, register))
+        return { set: false, line: NO_TARGET, provenLines: [] };
+    const withTarget = register.objects.filter((o) => isActive(o) && o.proof?.target?.level);
+    const judged = withTarget.filter((o) => !isKept(o));
+    const meets = judged.filter((o) => o.proof.proven).length;
+    const keptBelow = withTarget.filter((o) => isKept(o) && !o.proof.proven).length;
+    // Final review I1: a fix the check did not pass in full, with nothing open for its target, says so by name.
+    const provenLines = register.objects.filter((o) => isActive(o) && provenForTarget(o))
+        .sort((a, b) => a.name.localeCompare(b.name, 'en')).map((o) => `${o.name}: ${provenForTargetWords(o)}.`);
+    const whole = targetsOf(project).filter((t) => !t.packages);
+    const level = whole.length === 1 ? ` (${whole[0].level})` : '';
+    return {
+        set: true, meets, of: judged.length, keptBelow,
+        line: `${count(meets)} of ${plural(judged.length, 'object meets', 'objects meet')} your target${level}.`,
+        keptLine: keptBelow ? `${plural(keptBelow, 'object is', 'objects are')} kept below your target, by decision.` : '',
+        provenLines,
+    };
+}
+function levelsOf(register) {
+    const now = register.totals.byLevel.now;
+    const rows = ['A', 'B', 'C', 'D'].map((l) => ({ level: l, word: l, n: now[l] ?? 0, key: LEVEL_KEY[l] }));
+    rows.push({ level: 'none', word: 'Not assessed', n: now.none ?? 0, key: LEVEL_KEY.none });
+    const nothing = register.totals.byLevel.nothingToDecide ?? 0;
+    if (nothing)
+        rows.push({ level: 'nothing', word: 'Clean, nothing to decide', n: nothing, key: LEVEL_KEY.nothing });
+    return rows;
+}
+/** Everything that waits for a person, in a fixed order of kinds; oldest first inside a kind. */
+export function decisionsNeeded(project, register) {
+    const lead = project?.lead?.name ?? 'the lead';
+    const who = (o) => ownerOf(register, o) ?? lead;
+    const items = [];
+    const add = (kind, o, text, decides, since) => items.push({ kind, key: o.key, name: o.name, text, decides, since: since ?? null });
+    for (const o of register.objects) {
+        if (o.decision?.conflict) {
+            const at = (o.decisionHistory ?? []).reduce((a, d) => (d.at > a ? d.at : a), '');
+            add('conflict', o, `Settle the different decisions on ${o.name}.`, lead, at || null);
+        }
+    }
+    for (const o of register.objects)
+        if (o.retireCandidate === true)
+            add('retire', o, `Retire ${o.name}?`, lead, o.decision?.at);
+    for (const o of register.objects) {
+        if (isKept(o) && o.decision?.exception === true && !o.decision?.reason)
+            add('reason', o, `Give the reason ${o.name} is kept.`, lead, o.decision?.at);
+    }
+    for (const o of register.objects)
+        if (o.state === 'did-not-hold' && !provenForTarget(o))
+            add('failed', o, `${o.name}: the fix failed the check. Fix it again?`, who(o), o.lastMeasuredAt);
+    for (const o of register.objects)
+        if (o.state === 'regressed' && !provenForTarget(o))
+            add('regressed', o, `${o.name} has more findings than before. Look again?`, who(o), o.lastMeasuredAt);
+    // Not here (ruling on review finding 5): objects nobody has decided yet. That
+    // is the developer's own triage, counted on its own in the headline.
+    const order = ['conflict', 'retire', 'reason', 'failed', 'regressed'];
+    // One line per object: the first kind in this order wins.
+    const seen = new Set();
+    const once = items.filter((x) => order.indexOf(x.kind) >= 0).sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind))
+        .filter((x) => (seen.has(x.key) ? false : (seen.add(x.key), true)));
+    return once.sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind)
+        || (ms(a.since) || 0) - (ms(b.since) || 0) || a.name.localeCompare(b.name, 'en'));
+}
+/** Counted measurements of one object, oldest first, with their run time. */
+const countedOf = (register, o) => (o.measurements ?? [])
+    .filter((m) => m.counted && register.runs?.[m.run]?.at)
+    .map((m) => ({ at: register.runs[m.run].at, open: m.open }))
+    .sort((a, b) => ms(a.at) - ms(b.at));
+const lastClaimAt = (o) => (o.fixes ?? []).filter((f) => f.status === 'fixed').map((f) => f.at).sort((a, b) => ms(a) - ms(b)).pop() ?? null;
+/** When a verified object became verified: the latest check with nothing open that followed one with findings. */
+export function provenAt(register, o) {
+    let at = null;
+    let before = null;
+    for (const m of countedOf(register, o)) {
+        if (before !== null && before > 0 && m.open === 0)
+            at = m.at;
+        before = m.open;
+    }
+    return at;
+}
+/** When a fix did not hold: the first check after the newest claim that still had findings. */
+export function failedAt(register, o) {
+    const claim = ms(lastClaimAt(o));
+    const m = countedOf(register, o).find((x) => (!Number.isFinite(claim) || ms(x.at) > claim) && x.open > 0);
+    return m?.at ?? null;
+}
+/** Events recorded inside (from, to]: newest first. Each names one object or one plan change. */
+export function eventsBetween(register, from, to) {
+    const lo = ms(from);
+    const hi = ms(to);
+    const inside = (iso) => { const t = ms(iso); return Number.isFinite(t) && (!Number.isFinite(lo) || t > lo) && (!Number.isFinite(hi) || t <= hi); };
+    const out = { proven: [], provenForTarget: [], failed: [], reported: [], decided: [], plan: [] };
+    for (const o of register.objects) {
+        // Keyed on the TRANSITION, never on lastMeasuredAt: a later run that only
+        // confirms the same state must not announce it again (review finding 2).
+        if (o.state === 'verified' && inside(provenAt(register, o)))
+            out.proven.push(o.name);
+        else if (provenForTarget(o)) {
+            if (inside(failedAt(register, o)))
+                out.provenForTarget.push(o.name);
+        }
+        else if (o.state === 'did-not-hold' && inside(failedAt(register, o)))
+            out.failed.push(o.name);
+        // "Waiting for a check" only while it still is: a fix proven or failed since is said once, above (finding 1).
+        else if ((o.state === 'claimed' || o.state === 'working') && (o.fixes ?? []).some((f) => f.status === 'fixed' && inside(f.at)))
+            out.reported.push(o.name);
+        if ((o.decisionHistory ?? []).some((d) => inside(d.at)))
+            out.decided.push(o.name);
+    }
+    for (const c of register.plan?.history ?? [])
+        if (inside(c.at))
+            out.plan.push(c.what);
+    return out;
+}
+function changedOf(register, previousAsOf, asOf) {
+    if (!previousAsOf)
+        return { first: true, since: null, lines: [], more: 0, moreObjects: 0, line: FIRST_REPORT };
+    const e = eventsBetween(register, previousAsOf, asOf);
+    // The third value says where the names a line leaves out can be found: the
+    // History sheet holds check runs, fixes, decisions and plan changes; which
+    // objects a check proved or failed is on the Objects sheet.
+    const groups = [
+        [e.proven, (n) => `${plural(n, 'fix', 'fixes')} proven by the check`, 'objects'],
+        [e.provenForTarget, (n) => `${plural(n, 'fix', 'fixes')} proven for your target`, 'objects'],
+        [e.failed, (n) => `${plural(n, 'fix', 'fixes')} failed the check`, 'objects'],
+        [e.reported, (n) => `${plural(n, 'fix', 'fixes')} reported, waiting for a check`, 'history'],
+        [e.decided, (n) => `${plural(n, 'object', 'objects')} with a decision recorded`, 'history'],
+        [e.plan, (n) => `${plural(n, 'plan change', 'plan changes')}`, 'history'],
+    ].filter(([names]) => names.length);
+    let more = 0;
+    let moreObjects = 0;
+    const lines = groups.map(([names, words, where]) => {
+        const shown = names.slice(0, 3);
+        const left = names.length - shown.length;
+        if (where === 'history')
+            more += left;
+        else
+            moreObjects += left;
+        return `${words(names.length)}: ${shown.join(', ')}${left ? ` and ${count(left)} more` : ''}.`;
+    });
+    return {
+        first: false, since: previousAsOf, lines, more, moreObjects,
+        line: lines.length ? '' : `Nothing was recorded since the last report on ${dayWords(previousAsOf)}.`,
+    };
+}
+/** The rebuild group (review F17). Absent `evidence.rebuild` → planned from the decision only (I13). */
+export function rebuildGroup(register, asOf) {
+    const g = { planned: 0, handedOff: 0, inProgress: 0, built: 0, proven: 0, retired: 0, stale: [] };
+    const now = ms(asOf);
+    for (const o of register.objects) {
+        const r = rebuildOf(o);
+        if (o.state === 'retired' && r) {
+            g.retired += 1;
+            continue;
+        }
+        if (!r) {
+            if (isRebuild(o) && o.state !== 'retired')
+                g.planned += 1;
+            continue;
+        }
+        if (r.status === 'handed-off') {
+            g.handedOff += 1;
+            if (Number.isFinite(now) && Number.isFinite(ms(r.at)) && now - ms(r.at) > 14 * DAY_MS)
+                g.stale.push({ name: o.name, at: r.at });
+        }
+        else if (r.status === 'started')
+            g.inProgress += 1;
+        else if (r.status === 'built')
+            g.built += 1;
+        else if (r.status === 'proven')
+            g.proven += 1;
+    }
+    g.total = g.planned + g.handedOff + g.inProgress + g.built + g.proven + g.retired;
+    g.words = [
+        ['planned', g.planned], ['handed off', g.handedOff], ['in progress', g.inProgress],
+        ['built, not yet checked', g.built], ['built and proven', g.proven], ['old retired', g.retired],
+    ].map(([w, n]) => `${count(n)} ${w}`);
+    g.staleLines = g.stale.map((s) => `${s.name}: handed off on ${dayWords(s.at)}, not started.`);
+    return g;
+}
+/** One row per lane, in lanes.json order — never sorted by a count (review F11). */
+export function laneRows(register, asOf) {
+    const now = ms(asOf);
+    const rowOf = (owner, laneId, objects) => {
+        const claimed = objects.filter((o) => o.state === 'claimed');
+        const claimTimes = claimed.map((o) => Math.max(...(o.fixes ?? []).filter((f) => f.status === 'fixed').map((f) => ms(f.at)).filter(Number.isFinite), -Infinity))
+            .filter(Number.isFinite);
+        const oldest = claimTimes.length && Number.isFinite(now) ? Math.max(0, Math.floor((now - Math.min(...claimTimes)) / DAY_MS)) : null;
+        const packages = [...new Set(objects.map((o) => o.package))].sort((a, b) => a.localeCompare(b, 'en'));
+        const last = objects.map((o) => o.lastMeasuredAt).filter(Boolean).sort().pop() ?? null;
+        return {
+            laneId, developer: owner, packages,
+            packagesWord: packages.length > 3 ? `${packages.slice(0, 3).join(', ')} and ${packages.length - 3} more` : packages.join(', '),
+            objects: objects.length,
+            decided: objects.filter((o) => o.decision).length,
+            fixesProven: objects.filter((o) => o.state === 'verified').length,
+            awaiting: claimed.length, oldestDays: oldest,
+            kept: objects.filter(isKept).length,
+            rebuilds: objects.filter((o) => isRebuild(o) || rebuildOf(o)).length,
+            fixFailed: objects.filter((o) => o.state === 'did-not-hold' && !provenForTarget(o)).length,
+            lastCheck: last,
+            next: [],
+        };
+    };
+    // A person with two lanes is two rows; the lane id tells them apart.
+    const twice = new Set(register.lanes.map((l) => l.owner).filter((o, i, all) => all.indexOf(o) !== i));
+    const rows = register.lanes.map((l) => ({
+        ...rowOf(twice.has(l.owner) ? `${l.owner} (${l.id})` : l.owner, l.id, register.objects.filter((o) => inLane(o, l.id))),
+        // The lane's next objects, in the priority order every surface sorts by (register-core's `next`).
+        next: (l.next ?? []).slice(0, 3).map((k) => k.slice(k.indexOf('|') + 1)),
+    }));
+    // Active objects only: a retired or out-of-scope object needs no owner.
+    const unowned = register.objects.filter((o) => o.lane === null && isActive(o));
+    if (unowned.length)
+        rows.push(rowOf('No owner yet', null, unowned));
+    return rows;
+}
+export const awaitingWord = (r) => (r.awaiting ? `${count(r.awaiting)}${r.oldestDays !== null ? ` (oldest ${plural(r.oldestDays, 'day', 'days')})` : ''}` : '0');
+export const lastCheckWord = (r) => (r.lastCheck ? dayWords(r.lastCheck) : 'not yet');
+function keptList(register) {
+    return register.objects.filter((o) => isKept(o) && o.state !== 'retired').map((o) => ({
+        name: o.name, type: o.type,
+        line: `${o.name} kept${o.decision.level ? ` at ${o.decision.level}` : ''}${o.decision.exception ? ' as an accepted exception' : ''}, ${o.decision.reason ? 'reason recorded' : 'no reason recorded'}.`,
+        why: o.decision.reason ?? '',
+        by: `Decided by ${o.decision.by}${o.decision.at ? ` on ${dayWords(o.decision.at)}` : ''}.`,
+    })).sort((a, b) => a.name.localeCompare(b.name, 'en'));
+}
+/** Why "Objects" can be more than the coverage line's "of m": retired and out-of-scope objects are not checked. */
+function objectsSub(t) {
+    const retired = t.byState?.retired ?? 0;
+    const parts = [retired ? `${count(retired)} retired` : '', t.outOfScope ? `${count(t.outOfScope)} taken out of scope` : ''].filter(Boolean);
+    return parts.length ? `${parts.join(', ')}; not checked` : 'in the team project';
+}
+/** "with its reason" only when every kept object has one. */
+function keptSub(register) {
+    const kept = register.objects.filter((o) => isKept(o) && o.state !== 'retired');
+    const missing = kept.filter((o) => !o.decision.reason).length;
+    return missing ? `by decision; ${plural(missing, 'has', 'have')} no reason recorded` : 'by decision, with its reason';
+}
+/**
+ * The whole report, worked out once.
+ * @param {{ project: object, register: object, asOf: string, previousAsOf?: string|null }} input
+ */
+export function reportView({ project, register, asOf, previousAsOf = null }) {
+    const t = register.totals;
+    const coverage = coverageOf(project, register);
+    const needed = decisionsNeeded(project, register);
+    const kept = (t.byDisposition?.keep ?? 0) + (t.byDisposition?.exception ?? 0);
+    const fixesProven = t.byState.verified ?? 0;
+    const packages = new Set(register.objects.map((o) => o.package)).size;
+    const estate = register.estate;
+    const sid = estate?.system?.sid;
+    const scope = `${plural(t.objects, 'object', 'objects')} in ${plural(packages, 'package', 'packages')}`
+        + `${estate ? `, of ${count(estate.totals.codeObjects)} code objects${sid ? ` on ${sid}` : ' on the system'}` : ''}.`;
+    const rebuilds = rebuildGroup(register, asOf);
+    const fromFile = t.fromFile?.verified ?? 0;
+    const numbers = [
+        { id: 'objects', n: t.objects, label: 'Objects', sub: objectsSub(t) },
+        { id: 'decided', n: t.decided, label: 'Decided', sub: 'a person recorded what to do' },
+        { id: 'fixesProven', n: fixesProven, label: 'Fixes proven', sub: fromFile ? `${count(fromFile)} of them measured from a file` : 'a check passed after the fix' },
+        { id: 'awaiting', n: t.byState.claimed ?? 0, label: 'Fixed, awaiting check', sub: 'reported fixed, not checked since' },
+        { id: 'kept', n: kept, label: 'Kept as is', sub: keptSub(register) },
+        ...(rebuilds.total > 0 ? [{ id: 'rebuilds', n: rebuilds.total, label: 'Rebuilds', sub: 'decided to be built again' }] : []),
+    ];
+    // Objects with findings nobody has decided yet: the team's own triage, not a decision for someone else.
+    const notDecided = register.objects.filter((o) => isActive(o) && !o.decision && (o.openFindings ?? 0) > 0).length;
+    const headline = `${plural(fixesProven, 'fix', 'fixes')} proven by your check · ${plural(needed.length, 'decision', 'decisions')} waiting · ${count(kept)} kept by decision`
+        + `${notDecided ? ` · ${plural(notDecided, 'object', 'objects')} not decided yet` : ''}.`;
+    return {
+        asOf, coverage, headline, scope, numbers, fromFile,
+        trend: findingsTrend(register),
+        levels: levelsOf(register),
+        target: targetOf(project, register),
+        decisions: { total: needed.length, shown: needed.slice(0, 5), more: Math.max(0, needed.length - 5), all: needed },
+        changed: changedOf(register, previousAsOf, asOf),
+        lanes: laneRows(register, asOf),
+        kept: keptList(register),
+        rebuilds,
+    };
+}
+/** "Findings in your check at each check run: 62 → 47." Empty below two runs. */
+export const trendLine = (trend) => (trend.length < 2 ? ''
+    : `Findings in your check at each check run: ${trend.map((p) => count(p.findings)).join(' → ')} (each object counts its latest check).`);
+const decisionLine = (d) => `${d.text} Decides: ${d.decides}.${d.since ? ` Since ${dayWords(d.since)}.` : ''}`;
+export { decisionLine };
+/**
+ * The page's first block as terminal lines: what `cspeach team status` prints first.
+ */
+export function firstBlockLines(view) {
+    const lines = [view.coverage.line];
+    const trend = trendLine(view.trend);
+    if (trend)
+        lines.push(trend);
+    for (const note of view.coverage.notes)
+        lines.push(note);
+    lines.push(view.headline, view.scope, '');
+    for (const x of view.numbers)
+        lines.push(`  ${String(count(x.n)).padStart(6)}  ${x.label}`);
+    if (view.fromFile)
+        lines.push(`  ${count(view.fromFile)} of the fixes proven ${view.fromFile === 1 ? 'was' : 'were'} measured from a file.`);
+    lines.push('');
+    lines.push(`Levels now: ${view.levels.map((l) => `${l.word} ${count(l.n)}`).join(' · ')}.`);
+    lines.push(view.target.set ? view.target.line : NO_TARGET_LINE);
+    if (view.target.keptLine)
+        lines.push(view.target.keptLine);
+    for (const l of view.target.provenLines ?? [])
+        lines.push(l);
+    lines.push('');
+    if (view.decisions.total) {
+        lines.push(`Decisions needed: ${count(view.decisions.total)}`);
+        for (const d of view.decisions.shown)
+            lines.push(`  ${decisionLine(d)}`);
+        if (view.decisions.more)
+            lines.push(`  and ${count(view.decisions.more)} more in the workbook.`);
+    }
+    else
+        lines.push('Decisions needed: none.');
+    const c = view.changed;
+    lines.push('');
+    if (c.first)
+        lines.push('Changed since the last report:', `  ${c.line}`);
+    else {
+        lines.push(`Changed since the last report, ${dayWords(c.since)}:`);
+        if (c.line)
+            lines.push(`  ${c.line}`);
+        for (const l of c.lines)
+            lines.push(`  ${l}`);
+        if (c.more)
+            lines.push('  The ones left out are in History.');
+    }
+    return lines;
+}
+/* ── The workbook's four sheets: rows only, the CLI writes the file ──────── */
+const usageWord = (u) => { const c = usageCellOf(u); return c === 'unknown' && !isOutsideUsageWindowLine(u.why) ? 'not recorded' : c; };
+const callersWord = (o) => (o.evidence?.callers?.read ? o.evidence.callers.objects : 'not read');
+/** Summary: the page's numbers, the coverage row first. */
+export function summarySheetRows(view, { madeFor = '' } = {}) {
+    const rows = [
+        [view.coverage.line, ''],
+        ...view.coverage.notes.map((note) => [note, '']),
+        ['As of', utcWords(view.asOf)],
+        [view.headline, ''],
+        [view.scope, ''],
+        [],
+        ...view.numbers.map((x) => [x.label, x.n]),
+        [],
+        ...view.levels.map((l) => [['A', 'B', 'C', 'D'].includes(l.level) ? `Level ${l.word}: ${l.key}` : l.word, l.n]),
+        [view.target.set ? view.target.line : NO_TARGET_LINE, ''],
+        ...(view.target.keptLine ? [[view.target.keptLine, '']] : []),
+        ...(view.target.provenLines ?? []).map((l) => [l, '']),
+        ...(view.target.set ? [[READING_LINE, '']] : []),
+        ['Decisions needed', view.decisions.total],
+        ...(view.rebuilds.total ? [[`Rebuilds: ${view.rebuilds.words.join(' · ')}`, view.rebuilds.total]] : []),
+        [],
+        ['By lane / developer (lanes in their set order)', ''],
+        ['Developer', 'Lane packages', 'Objects', 'Decided', 'Fixes proven', 'Awaiting check', 'Kept', 'Rebuilds', 'Fix failed', 'Last check'],
+        ...view.lanes.map((r) => [r.developer, r.packages.join(', '), r.objects, r.decided, r.fixesProven, awaitingWord(r), r.kept, r.rebuilds, r.fixFailed, lastCheckWord(r)]),
+        [],
+        [madeFor, ''],
+        [FIX_RULE, ''],
+        ['Edit only the five columns before the dash on the Objects sheet, then: cspeach team plan import <file>', ''],
+        ['Changes made by someone else after this export are shown and skipped, never overwritten.', ''],
+        [EXPORT_LINE, ''],
+    ];
+    return rows;
+}
+export const OBJECTS_EXTRA = ['Level now', 'Reason', 'Last check', 'Checked with'];
+/** The plan's "Level" is the level a person decided; beside "Level now" it says so. */
+export const OBJECTS_COLUMNS = [...PLAN_COLUMNS.map((c) => (c === 'Level' ? 'Level decided' : c)), ...OBJECTS_EXTRA];
+/** Objects: the Plan sheet's columns (so plan import reads it), then four read-only facts. */
+export function objectsSheetRows(register, variant) {
+    const byKey = new Map(register.objects.map((o) => [`${o.type}|${o.name}`.toUpperCase(), o]));
+    return planRows(register).map((row) => {
+        const o = byKey.get(`${row[1]}|${row[0]}`.toUpperCase());
+        return [...row, o?.levelNow ?? '', o?.decision?.reason ?? '', o?.lastMeasuredAt ? utcWords(o.lastMeasuredAt) : 'not checked', o?.lastMeasuredAt ? variant : ''];
+    });
+}
+export const BUSINESS_COLUMNS = ['Object', 'Type', 'Package', 'Owner', 'Proposal', 'Reason', 'Decided by', 'Last changed', 'Callers', 'Usage', 'Confirm'];
+/** For the business: retire, rebuild and kept rows, with their evidence, and an empty Confirm column. */
+export function businessSheetRows(register) {
+    const proposal = (o) => {
+        if (o.retireCandidate)
+            return 'retire (candidate)';
+        const c = classOf(o);
+        if (c === 'retire')
+            return 'retire';
+        if (c === 'redesign')
+            return 'rebuild beside the core';
+        if (c === 'keep')
+            return o.decision.exception ? 'kept, accepted exception' : 'kept as is';
+        return null;
+    };
+    return register.objects.filter((o) => proposal(o) && !(o.state === 'retired' && !o.retireCandidate))
+        .sort((a, b) => a.package.localeCompare(b.package, 'en') || a.name.localeCompare(b.name, 'en'))
+        .map((o) => [
+        o.name, o.type, o.package, ownerOf(register, o) ?? 'nobody yet', proposal(o), o.decision?.reason ?? '',
+        o.decision ? `${o.decision.by}${o.decision.at ? `, ${utcWords(o.decision.at)}` : ''}` : '',
+        o.evidence?.changed?.at ? o.evidence.changed.at.slice(0, 10) : 'not read', callersWord(o), usageWord(o.evidence?.usage ?? { state: 'unknown' }), '',
+    ]);
+}
+export const HISTORY_COLUMNS = ['When', 'Who', 'What', 'Object', 'Why'];
+const DECISION_WORD = { keep: 'keep', fix: 'fix', retire: 'retire', redesign: 'rebuild beside the core' };
+const FIX_WORD = { fixed: 'fix reported', skipped: 'fix skipped', failed: 'fix failed', pending: 'fix pending' };
+const HISTORY_CAP = 5000;
+/** History: one event log from the rows the folder already holds (plan changes, decisions, fixes). Newest first. */
+export function historySheetRows(register) {
+    const rows = [];
+    for (const r of register.runs ?? []) {
+        rows.push([r.at, r.by, `check run: ${plural(r.findings ?? 0, 'finding', 'findings')}, ${r.atcVariant ?? 'variant not recorded'}${r.basis === 'file' ? ', from a file' : ''}`,
+            plural(r.objects ?? 0, 'object', 'objects'), r.scope ?? '']);
+    }
+    for (const c of register.plan?.history ?? []) {
+        rows.push([c.at, c.by, `plan: ${c.what}`, (c.keys ?? []).map((k) => k.slice(k.indexOf('|') + 1)).join(', ') + (c.more ? ` and ${c.more} more` : ''), c.why ?? '']);
+    }
+    for (const o of register.objects) {
+        for (const d of o.decisionHistory ?? []) {
+            rows.push([d.at, d.by, `${d.ruling ? 'ruling' : 'decision'}: ${DECISION_WORD[d.classification] ?? d.classification}${d.superseded ? ' (replaced later)' : ''}`, o.name, d.reason ?? '']);
+        }
+        for (const f of o.fixes ?? [])
+            rows.push([f.at, f.by, `${FIX_WORD[f.status] ?? `fix ${f.status}`}: ${f.rule}`, o.name, '']);
+    }
+    return rows.sort((a, b) => (ms(b[0]) || 0) - (ms(a[0]) || 0)).slice(0, HISTORY_CAP).map((r) => [utcWords(r[0]), ...r.slice(1)]);
+}