@cspeach/cli 1.1.48 → 1.1.50

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

@@ -11,17 +11,25 @@
  * 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):
+ * Pure: the project view and its Register in, plain data out. No DOM and no
+ * clock — `asOf` is handed in. Every count and word about an object comes from
+ * the project view (register-core `projectView`, design 2026-10-21), built
+ * once by the caller; the register is read only for what the view does not
+ * carry (the runs, the history of records). 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;
+ *  - "active" is said wherever it is the denominator, and retired and out of
+ *    scope objects are their own parts, said apart — never a bare "of 21"
+ *    beside a bare "28 objects";
+ *  - "fix proven" is the view's proven part — 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.
+ *  - developers are listed in lane order (lanes.json), never by a count; each
+ *    object counts once, in the lane that owns it.
  */
-import { PLAN_COLUMNS, inLane, isOutsideUsageWindowLine, planRows, provenForTarget, provenForTargetWords, targetsOf, usageCellOf, utcWords } from '@cspeach/register-core';
+import { DECISION_WORDS, PLAN_COLUMNS, decisionWhatOf, fixFailedAt, isOutsideUsageWindowLine, overlapNote, planRows, 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;
@@ -68,38 +76,25 @@ export function asOfFromStatusHtml(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;
+/** The parts that are not active: said apart wherever the active count divides. */
+const ASIDE = ['retired', 'out-of-scope'];
 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;
+/** "7 retired, not checked · 1 taken out of scope, not checked": the parts the coverage line does not count, each said once. */
+const asideWords = (view) => ASIDE.filter((p) => view.all.parts[p] > 0).map((p) => `${view.words.part(p, view.all.parts[p])}, not checked`);
+function coverageOf(view, register) {
+    const c = view.all.coverage;
+    const { checked, of, notChecked, variant, fromFile, notRun } = c;
+    const at = c.lastCheckAt;
     const cut = notChecked > 0 && notRun > 0 ? ` (the last check run stopped before reaching ${count(Math.min(notRun, notChecked))} of them)` : '';
+    const aside = asideWords(view).map((w) => ` · ${w}`).join('');
     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.`;
+        ? `Checked ${count(checked)} of ${plural(of, 'active object', 'active objects')} with ${variant}, latest check on ${whenWords(at)}${fromFile ? ', from a file' : ''} · ${count(notChecked)} not checked${cut}${aside}.`
+        : `Checked 0 of ${plural(of, 'active object', 'active objects')} with ${variant} · ${count(of)} not checked${aside}.`;
     // What a reader two forwards away cannot look up in the folder: where the
     // results came from, and what was left out.
     const notes = [];
@@ -138,81 +133,43 @@ export function findingsTrend(register) {
         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))
+/** Does any target exist that a person set? The view's answer (controller ruling for T3/T4). */
+export const hasTarget = (view) => view.all.target.any;
+function targetOf(view) {
+    const t = view.all.target;
+    if (!t.any)
         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 provenLines = view.all.objects.filter((v) => v.part === 'proven' && v.proof.provenForTarget)
+        .sort((a, b) => a.name.localeCompare(b.name, 'en')).map((v) => `${v.name}: ${v.proof.fixState}.`);
+    const whole = t.project.filter((x) => !x.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.` : '',
+        set: true, meets: t.meets, of: t.of, keptBelow: t.keptBelow,
+        line: `${count(t.meets)} of ${plural(t.of, 'object meets', 'objects meet')} your target${level}.`,
+        keptLine: t.keptBelow ? `${plural(t.keptBelow, 'object is', 'objects are')} kept below your target, by decision.` : '',
         provenLines,
     };
 }
-function levelsOf(register) {
-    const now = register.totals.byLevel.now;
+function levelsOf(view) {
+    const { now, nothingToDecide: nothing } = view.all.levels;
     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'));
-}
+/**
+ * Everything that waits for a person, in a fixed order of kinds; oldest first
+ * inside a kind; one line per object. The view's list (design §2 "Needs a
+ * person"): not worked out here.
+ */
+export const decisionsNeeded = (view) => view.all.needs;
 /** 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;
@@ -224,14 +181,12 @@ export function provenAt(register, o) {
     }
     return at;
 }
-/** When a fix did not hold: the first check after the newest claim that still had findings. */
+/** When a fix did not hold: the first check after the newest claim that still had findings (register-core's, the view's rule). */
 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;
+    return fixFailedAt(register, o);
 }
-/** Events recorded inside (from, to]: newest first. Each names one object or one plan change. */
-export function eventsBetween(register, from, to) {
+/** Events recorded inside (from, to]: newest first. Each names one object or one plan change. "Proven for target" is the view's. */
+export function eventsBetween(register, view, 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); };
@@ -241,7 +196,7 @@ export function eventsBetween(register, from, to) {
         // 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)) {
+        else if (view.object(o.key)?.proof.provenForTarget) {
             if (inside(failedAt(register, o)))
                 out.provenForTarget.push(o.name);
         }
@@ -258,10 +213,10 @@ export function eventsBetween(register, from, to) {
             out.plan.push(c.what);
     return out;
 }
-function changedOf(register, previousAsOf, asOf) {
+function changedOf(register, view, previousAsOf, asOf) {
     if (!previousAsOf)
         return { first: true, since: null, lines: [], more: 0, moreObjects: 0, line: FIRST_REPORT };
-    const e = eventsBetween(register, previousAsOf, asOf);
+    const e = eventsBetween(register, view, 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.
@@ -289,25 +244,35 @@ function changedOf(register, previousAsOf, asOf) {
         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) {
+/**
+ * The rebuild group (review F17), over the project view's objects (Task 9 fix round 2): planned = the
+ * view's rebuild part with no rebuild started (I13); the others by the status of the rebuild row; an
+ * object the lead took out of scope is in no count. The register is read only for the rebuild row's
+ * status and time (when a hand-off went stale).
+ */
+export function rebuildGroup(register, asOf, view) {
     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;
+    const byKey = new Map(register.objects.map((o) => [o.key, o]));
+    for (const v of view.all.objects) {
+        if (v.part === 'out-of-scope')
+            continue;
+        const o = byKey.get(v.key);
+        const r = o ? rebuildOf(o) : null;
+        if (v.part === 'retired') {
+            if (r)
+                g.retired += 1;
             continue;
         }
         if (!r) {
-            if (isRebuild(o) && o.state !== 'retired')
+            if (v.part === 'rebuild')
                 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 });
+                g.stale.push({ name: v.name, at: r.at });
         }
         else if (r.status === 'started')
             g.inProgress += 1;
@@ -324,103 +289,128 @@ export function rebuildGroup(register, asOf) {
     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) {
+/**
+ * One row per lane, in lanes.json order — never sorted by a count (review F11).
+ * The counts are the lane's parts in the view: each object counts once, in the
+ * lane that owns it, so the rows (with "No owner yet") add up to the objects.
+ * The register is read only for how long a claim has waited.
+ */
+export function laneRows(view, 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))
+    const byKey = new Map(register.objects.map((o) => [o.key, o]));
+    const rowOf = (owner, laneId, scope) => {
+        const claimTimes = scope.objects.filter((v) => v.part === 'awaiting-check')
+            .map((v) => Math.max(...(byKey.get(v.key)?.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;
+        const packages = [...new Set(scope.objects.map((v) => v.package))].sort((a, b) => a.localeCompare(b, 'en'));
+        const last = scope.objects.map((v) => v.proof.lastCheckAt).filter(Boolean).sort().pop() ?? null;
+        const p = scope.parts;
         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,
+            objects: scope.total, active: scope.active, retired: p.retired,
+            decided: scope.objects.filter((v) => v.decision.what !== 'none').length,
+            fixesProven: p.proven,
+            awaiting: p['awaiting-check'], oldestDays: oldest,
+            kept: p.kept,
+            rebuilds: p.rebuild,
+            fixFailed: p['failed-check'],
             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)),
+    const owners = view.lanes.map((s) => s.scope.owner);
+    const twice = new Set(owners.filter((o, i, all) => all.indexOf(o) !== i));
+    const rows = view.lanes.map((s) => ({
+        ...rowOf(twice.has(s.scope.owner) ? `${s.scope.owner} (${s.scope.id})` : s.scope.owner, s.scope.id, s),
+        // The lane's own next objects, in the priority order every surface sorts by (the view's `next`).
+        next: s.next.slice(0, 3).map((v) => v.name),
     }));
-    // 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));
+    if (view.unowned.total)
+        rows.push(rowOf('No owner yet', null, view.unowned));
     return rows;
 }
+/** "1 object also matches another lane. It counts once, in the lane that owns it." — or nothing. */
+export const lanesNote = (register) => overlapNote(register);
 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'));
+/** The kept part, by name. The reason says whose words it is (the view's words: "Why: …", "Reason (proposed, accepted by …): …"). */
+function keptList(view) {
+    return view.all.objects.filter((v) => v.part === 'kept').map((v) => {
+        const d = v.decision;
+        return {
+            name: v.name, type: v.type,
+            line: `${v.name} kept${v.level.decided ? ` at ${v.level.decided}` : ''}${d.what === 'exception' ? ' as an accepted exception' : ''}, ${d.reason ? 'reason recorded' : 'no reason recorded'}.`,
+            why: d.reason ? view.words.reason(d.reason, d.by) : '',
+            by: d.by ? `Decided by ${d.by.name}${d.by.at ? ` on ${dayWords(d.by.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';
+/** Why "Objects" can be more than the coverage line's "of m": "21 active; 7 retired, not checked". */
+function objectsSub(view) {
+    const aside = ASIDE.filter((p) => view.all.parts[p] > 0).map((p) => view.words.part(p, view.all.parts[p]));
+    return aside.length ? `${count(view.all.active)} active; ${aside.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;
+function keptSub(view) {
+    const missing = view.all.objects.filter((v) => v.part === 'kept' && !v.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
+ * The whole report, worked out once, from the project view. The view is
+ * required: the caller builds it once (`projectView(register, project)`) and
+ * hands it in; the register beside it is the one the view was built from.
+ * @param {{ view: 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;
+export function reportView({ view, register, asOf, previousAsOf = null }) {
+    if (!view?.all)
+        throw new Error('reportView needs the project view (projectView(register, project)), built once by the caller.');
+    const all = view.all;
+    const p = all.parts;
+    const coverage = coverageOf(view, register);
+    const needed = decisionsNeeded(view);
+    const packages = new Set(all.objects.map((v) => v.package)).size;
     const estate = register.estate;
     const sid = estate?.system?.sid;
-    const scope = `${plural(t.objects, 'object', 'objects')} in ${plural(packages, 'package', 'packages')}`
+    // "28 objects in 5 packages (21 active, 7 retired)": the parts the coverage line leaves out, said where the total is.
+    const aside = ASIDE.filter((x) => p[x] > 0).map((x) => view.words.part(x, p[x]));
+    const scope = `${plural(all.total, 'object', 'objects')} in ${plural(packages, 'package', 'packages')}`
+        + `${aside.length ? ` (${count(all.active)} active, ${aside.join(', ')})` : ''}`
         + `${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 rebuilds = rebuildGroup(register, asOf, view);
+    // Of the fixes proven, how many a file measured: the view's proof basis.
+    const fromFile = all.objects.filter((v) => v.part === 'proven' && v.proof.basis === 'file').length;
+    const decided = all.objects.filter((v) => v.decision.what !== 'none').length;
+    // The tiles that are parts carry the part's id; the parts add up to Objects.
     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' }] : []),
+        { id: 'objects', n: all.total, label: 'Objects', sub: objectsSub(view) },
+        { id: 'decided', n: decided, label: 'Decided', sub: 'a person recorded what to do' },
+        { id: 'fixesProven', part: 'proven', n: p.proven, label: 'Fixes proven', sub: fromFile ? `${count(fromFile)} of them measured from a file` : 'a check passed after the fix' },
+        { id: 'awaiting', part: 'awaiting-check', n: p['awaiting-check'], label: 'Fixed, awaiting check', sub: 'reported fixed, not checked since' },
+        { id: 'kept', part: 'kept', n: p.kept, label: 'Kept as is', sub: keptSub(view) },
+        ...(p.rebuild > 0 ? [{ id: 'rebuilds', part: 'rebuild', n: p.rebuild, label: 'Rebuilds', sub: 'decided to be built again' }] : []),
+        ...(p.retired > 0 ? [{ id: 'retired', part: 'retired', n: p.retired, label: 'Retired', sub: 'ruled by the lead; not checked' }] : []),
+        ...(p['out-of-scope'] > 0 ? [{ id: 'outOfScope', part: 'out-of-scope', n: p['out-of-scope'], label: 'Taken out of scope', sub: 'by the lead; not checked' }] : []),
     ];
     // 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`
+    const notDecided = all.objects.filter((v) => (v.part === 'undecided' || v.part === 'skipped') && (v.proof.open ?? 0) > 0).length;
+    const headline = `${plural(p.proven, 'fix', 'fixes')} proven by your check · ${plural(needed.length, 'decision', 'decisions')} waiting · ${count(p.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),
+        levels: levelsOf(view),
+        target: targetOf(view),
         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),
+        changed: changedOf(register, view, previousAsOf, asOf),
+        lanes: laneRows(view, register, asOf),
+        lanesNote: lanesNote(register),
+        kept: keptList(view),
+        // Active objects decided keep that the check counts in another part (clean, fix proven, awaiting or failed).
+        keptElsewhere: all.objects.filter((v) => (v.decision.what === 'keep' || v.decision.what === 'exception') && v.part !== 'kept'
+            && !ASIDE.includes(v.part)).length,
         rebuilds,
     };
 }
@@ -440,8 +430,9 @@ export function firstBlockLines(view) {
     for (const note of view.coverage.notes)
         lines.push(note);
     lines.push(view.headline, view.scope, '');
+    // The sub text after the label, so the terminal says why 28 objects are not 21 checked.
     for (const x of view.numbers)
-        lines.push(`  ${String(count(x.n)).padStart(6)}  ${x.label}`);
+        lines.push(`  ${String(count(x.n)).padStart(6)}  ${x.label}${x.sub ? ` — ${x.sub}` : ''}`);
     if (view.fromFile)
         lines.push(`  ${count(view.fromFile)} of the fixes proven ${view.fromFile === 1 ? 'was' : 'were'} measured from a file.`);
     lines.push('');
@@ -479,6 +470,8 @@ export function firstBlockLines(view) {
 /* ── 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');
+/** The lane table's columns, on the Summary sheet, the page and `team status`: each object once, in the lane that owns it. */
+export const LANE_COLUMNS = ['Developer', 'Lane packages', 'Objects', 'Active', 'Retired', 'Decided', 'Fixes proven', 'Awaiting check', 'Kept', 'Rebuilds', 'Fix failed', 'Last check'];
 /** Summary: the page's numbers, the coverage row first. */
 export function summarySheetRows(view, { madeFor = '' } = {}) {
     const rows = [
@@ -499,8 +492,9 @@ export function summarySheetRows(view, { madeFor = '' } = {}) {
         ...(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)]),
+        [...LANE_COLUMNS],
+        ...view.lanes.map((r) => [r.developer, r.packages.join(', '), r.objects, r.active, r.retired, r.decided, r.fixesProven, awaitingWord(r), r.kept, r.rebuilds, r.fixFailed, lastCheckWord(r)]),
+        ...(view.lanesNote ? [[view.lanesNote, '']] : []),
         [],
         [madeFor, ''],
         [FIX_RULE, ''],
@@ -510,49 +504,116 @@ export function summarySheetRows(view, { madeFor = '' } = {}) {
     ];
     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 : ''];
+/**
+ * The read-only facts after the plan columns. "Target set by" only when a target
+ * exists (no target words without a target); "Reason from" says whose words the
+ * Reason is.
+ */
+export const OBJECTS_EXTRA = ['Level now', 'Reason', 'Last check', 'Checked with', 'Level decided by', 'Reason from'];
+const PLAN_PART = PLAN_COLUMNS.map((c) => (c === 'Level' ? 'Level decided' : c));
+/** The plan's "Level" is the level a person decided; beside "Level now" it says so. The columns with no target set. */
+export const OBJECTS_COLUMNS = [...PLAN_PART, ...OBJECTS_EXTRA];
+/** The Objects sheet's columns for this view: "Target set by" after "Level decided by" when a target exists. */
+export function objectsSheetColumns(view) {
+    if (!view.all.target.any)
+        return [...OBJECTS_COLUMNS];
+    return [...PLAN_PART, 'Level now', 'Reason', 'Last check', 'Checked with', 'Level decided by', 'Target set by', 'Reason from'];
+}
+const REASON_FROM = { person: 'person', proposal: 'proposal, accepted', none: 'not recorded (older record)' };
+const targetSetBy = (t) => (t.from === 'person' ? t.by?.name ?? '' : t.from === 'project' ? `${t.by?.name ?? 'the lead'} (project target)` : '');
+/**
+ * Objects: the Plan sheet's columns (so plan import reads it), then the
+ * read-only facts, from the view: who decided the level (G8), who set the
+ * target, whose words the reason is.
+ */
+export function objectsSheetRows(register, view, variant) {
+    const withTarget = view.all.target.any;
+    return planRows(register, view).map((row) => {
+        const v = view.object(`${row[1]}|${row[0]}`.toUpperCase());
+        const checked = v?.proof.lastCheckAt ?? null;
+        const reason = v?.decision.reason ?? null;
+        return [...row, v?.level.now ?? '', reason?.text ?? '', checked ? utcWords(checked) : 'not checked', checked ? variant : '',
+            v?.level.by?.name ?? '',
+            ...(withTarget ? [v ? targetSetBy(v.target) : ''] : []),
+            reason?.text ? REASON_FROM[reason.from] ?? '' : ''];
     });
 }
 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)}` : ''}` : '',
+const BUSINESS_WORD = { 'retire-candidate': 'retire (candidate)', rebuild: 'rebuild beside the core', keep: 'kept as is', exception: 'kept, accepted exception' };
+/** For the business: retire candidates, rebuild and kept rows, with their evidence, and an empty Confirm column. The decision and owner are the view's. */
+export function businessSheetRows(register, view) {
+    // A retire candidate is counted as the tiles and team status count it: active objects only.
+    const proposal = (v) => (v.decision.what === 'retire-candidate' && (v.part === 'retired' || v.part === 'out-of-scope') ? null : BUSINESS_WORD[v.decision.what] ?? null);
+    return register.objects.map((o) => ({ o, v: view.object(o.key) })).filter(({ v }) => v && proposal(v))
+        .sort((a, b) => a.o.package.localeCompare(b.o.package, 'en') || a.o.name.localeCompare(b.o.name, 'en'))
+        .map(({ o, v }) => [
+        o.name, o.type, o.package, v.owner?.name ?? 'nobody yet', proposal(v), reasonCell(v.decision.reason),
+        v.decision.by ? `${v.decision.by.name}${v.decision.by.at ? `, ${utcWords(v.decision.by.at)}` : ''}` : '',
         o.evidence?.changed?.at ? o.evidence.changed.at.slice(0, 10) : 'not read', callersWord(o), usageWord(o.evidence?.usage ?? { state: 'unknown' }), '',
     ]);
 }
+/** A reason cell: a proposal's words say they were proposed (design rule 5), the same words History uses. */
+const reasonCell = (r) => (!r?.text ? '' : r.from === 'proposal' ? `proposed: ${r.text}` : r.text);
 export const HISTORY_COLUMNS = ['When', 'Who', 'What', 'Object', 'Why'];
-const DECISION_WORD = { keep: 'keep', fix: 'fix', retire: 'retire', redesign: 'rebuild beside the core' };
+/** The classifications the view has words for (Task 9 fix round 3); any other is said as the folder wrote it. */
+const VIEW_CLASSIFICATIONS = new Set(['keep', 'fix', 'retire', 'redesign']);
+/** A decision row in the view's words: a writer's retire is a candidate, the lead's is retired, an excepted keep an accepted exception. */
+const decisionWordOf = (d) => (VIEW_CLASSIFICATIONS.has(d.classification)
+    ? DECISION_WORDS[decisionWhatOf({ classification: d.classification, exception: d.exception, ruling: d.ruling === true })] : d.classification);
 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) {
+/** Short words a check id spells in capitals that read wrong in lower case. */
+const RULE_ACRONYMS = {
+    ABAP: 'ABAP', ALV: 'ALV', API: 'API', APIS: 'APIs', ATC: 'ATC', BAPI: 'BAPI', BADI: 'BAdI', CDS: 'CDS', DB: 'DB', DDIC: 'DDIC',
+    HANA: 'HANA', ID: 'ID', IDS: 'IDs', OO: 'OO', RAP: 'RAP', RFC: 'RFC', SAP: 'SAP', SLIN: 'SLIN', SQL: 'SQL', UI: 'UI', 'S/4HANA': 'S/4HANA',
+};
+const ruleWord = (w, first) => {
+    const known = RULE_ACRONYMS[w.toUpperCase()];
+    if (known)
+        return known;
+    const low = w.toLowerCase();
+    return first ? low.charAt(0).toUpperCase() + low.slice(1) : low;
+};
+/** A check named only by a system id (a GUID): it has no words a person can read. */
+const CHECK_WORDS = 'a check';
+const isCheckId = (head) => { const bare = head.replace(/[-_{}]/g, ''); return !bare || /^[0-9A-F]{16,}$/i.test(bare); };
+/**
+ * A check id in words: `USAGE_OF_RELEASED_APIS:4` reads "Usage of released APIs".
+ * The part after the last colon is the check's message id; it never shows.
+ * Underscores become spaces, sentence case. A check known only by its system
+ * id reads "a check". A person reads this on the History sheet; a check id they cannot.
+ */
+export function ruleWords(rule) {
+    const text = String(rule ?? '').trim();
+    const cut = text.lastIndexOf(':');
+    const head = cut > 0 ? text.slice(0, cut) : text;
+    if (isCheckId(head))
+        return CHECK_WORDS;
+    return head.split(/[_:\s]+/).filter(Boolean).map((w, i) => ruleWord(w, i === 0)).join(' ');
+}
+/** Who ran the counted check at this time on this object. */
+const checkBy = (register, o, at) => {
+    for (const m of o.measurements ?? []) {
+        const r = m.counted ? register.runs?.[m.run] : null;
+        if (r?.at === at)
+            return r.by ?? '';
+    }
+    return '';
+};
+/**
+ * History: one event log from the rows the folder already holds (plan changes, decisions, fixes, checks that proved or failed a fix). Newest first.
+ *
+ * The check rows ("fix proven", "fix failed the check") say what the object's fix IS now, at the check
+ * that made it so: they are read from the project view (Task 9 fix round 1). A fix the check left with
+ * findings that only matter for a stricter level is proven for its target, in the view's words. Without
+ * a view (unit tests over a bare register) the register's own state stands in.
+ */
+export function historySheetRows(register, view) {
     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' : ''}`,
+        // Objects with findings, never the finding rows: a finding in a shared include counts under every program (types.ts RegisterRun).
+        const found = Number.isFinite(r.withFindings) ? `: ${plural(r.withFindings, 'object with findings', 'objects with findings')},` : ',';
+        rows.push([r.at, r.by, `check run${found} ${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 ?? []) {
@@ -560,10 +621,37 @@ export function historySheetRows(register) {
     }
     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 ?? '']);
+            // A reason accepted from a proposal says so: the person said Yes to words they did not write (R4).
+            const why = d.reason ? (d.reasonFrom === 'proposal' && !d.ruling ? `proposed: ${d.reason}` : d.reason) : '';
+            rows.push([d.at, d.by, `${d.ruling ? 'ruling' : 'decision'}: ${decisionWordOf(d)}${d.superseded ? ' (replaced later)' : ''}`, o.name, why]);
+        }
+        // G7: one row per claim. Rules one person reported on this object at one time are one row, in words.
+        const claims = new Map();
+        for (const f of o.fixHistory ?? o.fixes ?? []) {
+            const id = JSON.stringify([f.by, f.at, f.status]);
+            if (!claims.has(id))
+                claims.set(id, { at: f.at, by: f.by, status: f.status, open: new Map() });
+            const c = claims.get(id);
+            if (!c.open.has(f.rule))
+                c.open.set(f.rule, Number.isFinite(f.openAtClaim) ? f.openAtClaim : null);
+        }
+        for (const c of claims.values()) {
+            // Two message ids of one check are one name. The count is the findings
+            // those rules had open at the last check before the claim; unknown, no count.
+            const names = [...new Set([...c.open.keys()].map(ruleWords))].join(', ');
+            const counts = [...c.open.values()];
+            const label = FIX_WORD[c.status] ?? `fix ${c.status}`;
+            const what = counts.every((n) => n !== null) ? `${label}: ${plural(counts.reduce((a, n) => a + n, 0), 'finding', 'findings')} — ${names}` : `${label} — ${names}`;
+            rows.push([c.at, c.by, what, o.name, '']);
         }
-        for (const f of o.fixes ?? [])
-            rows.push([f.at, f.by, `${FIX_WORD[f.status] ?? `fix ${f.status}`}: ${f.rule}`, o.name, '']);
+        // A fix counts when a check proves it: that check is its own row, by whoever ran it.
+        const proof = view?.object(o.key)?.proof ?? { state: o.state, provenForTarget: false, fixState: '' };
+        const proven = proof.state === 'verified' ? provenAt(register, o) : null;
+        if (proven && [...claims.values()].some((c) => c.status === 'fixed' && ms(c.at) <= ms(proven)))
+            rows.push([proven, checkBy(register, o, proven), 'fix proven', o.name, '']);
+        const failed = proof.state === 'did-not-hold' || proof.provenForTarget ? failedAt(register, o) : null;
+        if (failed)
+            rows.push([failed, checkBy(register, o, failed), proof.provenForTarget ? proof.fixState : 'fix failed the check', 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)]);
 }