@cspeach/cli 1.1.30 → 1.1.31

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

@@ -0,0 +1,168 @@
+// @ts-nocheck
+// GENERATED COPY — do not edit here. Edit viewer/src/lib/estate-parts.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 estate: what custom code the system holds, before anyone splits it up.
+ *
+ * Drawn from register-core's `EstateSummary` (the newest discovery file, read
+ * the strict way) and nothing else, so the page, the status file and the
+ * workbook count the same packages. Two places wear it: the Estate section of
+ * a team project page, and the whole page of a folder the lead has run
+ * discovery into but not yet made a team project from.
+ *
+ * The same rules as every other part of this page: every value out of the
+ * folder goes through `cell()` (or `esc()` for our own words), colour is a
+ * class and never a style attribute, and a count is a count — "last change" is
+ * when the code was changed and is never called use.
+ */
+import { esc } from './register-map.js';
+import { cell, n } from './register-parts.js';
+import { formatWhen } from './register-model.js';
+import { findingsByPackage, plainDate, shortUsageWindow, usageWindowOf } from '@cspeach/register-core';
+export const NO_ESTATE = 'No estate inventory yet. The lead runs cspeach team discover.';
+/** A discovery file is there but is not one this build can read (another kind or version). */
+export const ESTATE_UNREADABLE = 'The estate inventory in this folder could not be read.';
+/** As many package rows as a reader scans before the table stops helping. */
+const PACKAGE_ROWS = 100;
+const numberTile = (label, value, note) => `<li class="tile"><span class="tile-n">${n(value)}</span> <span class="tile-label">${esc(label)}</span> <span class="tile-note">${esc(note)}</span></li>`;
+/**
+ * Whether runtime usage is recorded, in the tile's own short words. The source
+ * is not named on screen; the workbook's Usage sources sheet says which one.
+ * Only an ACTIVE source can say usage is recorded — empty, off and not read
+ * all mean nothing on this system records which programs run.
+ *
+ * A window under 90 days, or one that ended more than 90 days before the
+ * report, says so: it is too short (or too old) to say what is unused, and the
+ * tile must not read as if it could (rehearsal fix 2).
+ *
+ * @param {string} [reportAt] when the report was made; the inventory's own time when not given
+ */
+function usageWords(estate, reportAt) {
+    const active = (estate.usageSources ?? []).find((s) => s.state === 'active');
+    if (!active)
+        return 'none recorded on this system';
+    if (!active.period)
+        return 'recorded, period not stated';
+    const window = usageWindowOf(estate.usageSources);
+    const weak = window ? shortUsageWindow(window, reportAt || estate.takenAt || '') : null;
+    if (weak) {
+        const span = `${plainDate(window.from)} – ${plainDate(window.to)}`;
+        return weak.short
+            ? `only ${weak.days} days (${span}) — too short to say what is unused`
+            : `${weak.days} days (${span}), ended over 90 days ago — too old to say what is unused`;
+    }
+    return `recorded from ${active.period.from} to ${active.period.to}`;
+}
+function tilesHtml(estate, reportAt) {
+    const t = estate.totals ?? {};
+    return '<ul class="tiles estate-tiles" data-role="estate-tiles">'
+        + numberTile('Packages', t.packages ?? 0, 'with custom code')
+        + numberTile('Code objects', t.codeObjects ?? 0, 'programs, classes, function groups')
+        + numberTile('Non-code objects', t.nonCodeObjects ?? 0, 'tables, data elements and the rest')
+        + numberTile('Outside packages', t.local ?? 0, 'local objects, never transported')
+        + numberTile('Modifications of SAP objects', t.modifications ?? 0, t.noteCorrections ? `not counting ${n(t.noteCorrections)} note corrections` : 'changes to SAP\x27s own code')
+        + `<li class="tile tile-words"><span class="tile-text">${esc(usageWords(estate, reportAt))}</span> <span class="tile-label">Usage data</span> <span class="tile-note">which programs run</span></li>`
+        + '</ul>';
+}
+function unknownsHtml(estate) {
+    const list = estate.unknowns ?? [];
+    if (!list.length)
+        return '<div class="estate-unknowns" data-role="estate-unknowns"><h3>Unknowns</h3><p class="quiet-note">Nothing is unknown: every step of the inventory read.</p></div>';
+    return '<div class="estate-unknowns" data-role="estate-unknowns"><h3>Unknowns</h3><ul>'
+        + list.map((u) => `<li><b>${cell(u.what)}</b> — ${u.why ? cell(u.why) : '<span class="quiet-note">no reason recorded</span>'}</li>`).join('')
+        + '</ul></div>';
+}
+/**
+ * @param {Record<string, number>} [findings] open findings per package, over
+ *   the objects a check has measured (register-core `findingsByPackage`); a
+ *   package with none measured has no key and says so.
+ */
+function packagesHtml(estate, { inScope, findings }) {
+    const all = estate.packages ?? [];
+    const shown = all.slice(0, PACKAGE_ROWS);
+    const heads = ['Package', 'Area', 'Objects', ...(findings ? ['Open findings'] : []), 'Last change', ...(inScope ? ['In scope'] : [])]
+        .map((h) => `<th scope="col">${h}</th>`).join('');
+    const row = (p) => `<tr><td><span class="ident">${cell(p.name)}</span>${p.text ? ` <span class="quiet-note">${cell(p.text)}</span>` : ''}</td>`
+        + `<td>${cell(p.area)}</td><td>${n(p.objects)}</td>`
+        + (findings ? `<td>${Object.hasOwn(findings, p.name) ? n(findings[p.name]) : '<span class="quiet-note">not measured</span>'}</td>` : '')
+        + `<td>${p.lastChanged ? cell(p.lastChanged.at) : '<span class="quiet-note">not recorded</span>'}</td>`
+        + (inScope ? `<td>${p.inScope ? 'in scope' : '<span class="quiet-note">not in scope</span>'}</td>` : '')
+        + '</tr>';
+    const more = all.length - shown.length;
+    return `<div class="scroller"><table data-role="estate-packages" aria-label="Packages with custom code"><thead><tr>${heads}</tr></thead>`
+        + `<tbody>${shown.map(row).join('')}</tbody></table></div>`
+        + (more > 0 ? `<p class="quiet-note" data-role="estate-more">and ${n(more)} more</p>` : '');
+}
+/**
+ * Inside a team project the whole system is one line, not a table of every
+ * package on it (rehearsal fix 3): the project is what the page is about, and
+ * the inventory workbook holds the rest.
+ */
+function wholeSystemHtml(estate) {
+    const t = estate.totals ?? {};
+    return `<p class="estate-whole" data-role="estate-whole">Whole system: ${n(t.packages ?? 0)} package${t.packages === 1 ? '' : 's'}, `
+        + `${n(t.codeObjects ?? 0)} code object${t.codeObjects === 1 ? '' : 's'} — see the inventory (estate.xlsx in the discovery folder).</p>`;
+}
+/**
+ * The estate section's body.
+ *
+ * @param {object|null|undefined} estate register-core `EstateSummary`
+ * @param {{ inScope?: boolean, findings?: Record<string, number>, unreadable?: boolean, now?: string }} [opts]
+ *   `inScope` — drawn inside a team project: the whole system is one line and
+ *   the In scope line follows; the package table is the estate-only view's.
+ *   `unreadable` — a discovery file was found but could not be read, so the
+ *   empty sentence must not say there is none.
+ *   `now` — when the report was made, for the usage tile.
+ */
+export function estateHtml(estate, { inScope = false, findings, unreadable = false, now } = {}) {
+    if (!estate) {
+        return unreadable
+            ? `<p class="empty-note" data-role="no-estate">${ESTATE_UNREADABLE}</p>`
+            : `<p class="empty-note" data-role="no-estate">${NO_ESTATE}</p>`;
+    }
+    const scope = inScope && estate.inScope
+        ? `<p class="estate-scope" data-role="estate-in-scope">In scope: ${n(estate.inScope.packages)} package${estate.inScope.packages === 1 ? '' : 's'}, ${n(estate.inScope.objects)} object${estate.inScope.objects === 1 ? '' : 's'}</p>`
+        : '';
+    if (inScope)
+        return `${tilesHtml(estate, now)}${wholeSystemHtml(estate)}${scope}${unknownsHtml(estate)}`;
+    return `${tilesHtml(estate, now)}${scope}${unknownsHtml(estate)}${packagesHtml(estate, { inScope: false, findings })}`;
+}
+/**
+ * The Estate section's body inside a team project, as the page and the status
+ * file both draw it: open findings per package come from register-core, so the
+ * two surfaces never count them two ways.
+ * @param {object} register
+ * @param {{ fileGiven?: boolean, now?: string }} [opts] a discovery file was in the folder; when the report was made
+ */
+export function estateSectionHtml(register, { fileGiven = false, now } = {}) {
+    return estateHtml(register.estate, {
+        inScope: true, findings: findingsByPackage(register), unreadable: fileGiven && !register.estate, now,
+    });
+}
+/**
+ * The whole page for a folder that holds a discovery and no team project yet.
+ * It says what it is, who took it and when, and the one step that comes next.
+ */
+export function estateOnlyPageHtml(estate, folderName, now) {
+    const taken = estate?.takenAt ? `Taken ${esc(formatWhen(estate.takenAt))}${estate.by ? ` by ${cell(estate.by)}` : ''}.` : '';
+    return `
+    <header class="masthead">
+      <p class="provenance">Estate inventory, read from the folder ${cell(folderName)}.</p>
+      <h1>The custom code on this system</h1>
+      <p class="summary">${taken} No team project yet. The lead makes one from this inventory with cspeach team init --from-discovery.</p>
+      <p class="notice" data-role="reload-note" hidden></p>
+      <div class="actions">
+        <button type="button" data-action="reload" class="primary">Read the folder again</button>
+        <button type="button" data-action="print" class="quiet">Print or save as PDF</button>
+        <button type="button" data-action="change-folder" class="quiet">Open another folder</button>
+      </div>
+    </header>
+    <section data-role="estate" class="estate" aria-labelledby="team-estate-heading">
+      <h2 id="team-estate-heading">Estate</h2>
+      ${estateHtml(estate, { unreadable: !estate, now })}
+    </section>
+    <footer>
+      <p data-role="trust">This page reads the files in your folder and draws them here, in your browser. Your browser blocks it from sending anything to any other site. The inventory holds package names, object counts, SAP user ids and dates. No source code. No passwords.</p>
+    </footer>`;
+}

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

@@ -0,0 +1,68 @@
+// @ts-nocheck
+// GENERATED COPY — do not edit here. Edit viewer/src/lib/plan-parts.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.
+/**
+ * Plan and changes (spec 2026-10-06 §9 item 8): how the working lists are
+ * ordered, and who changed that, when and why.
+ *
+ * Three things, read top to bottom: the priority weights in one line with where
+ * they came from; the focus stack in order, each with how much of it is done;
+ * and the change history, newest first, as register-core hands it. Shared by
+ * the page and the status file, so a manager reading either sees one plan.
+ *
+ * Every value out of the folder goes through `cell()`; our own words through
+ * `esc()`. No style attribute anywhere.
+ */
+import { esc } from './register-map.js';
+import { formatWhen } from './register-model.js';
+import { cell, dayWords, n, NO_FOCUS } from './register-parts.js';
+import { DEFAULT_WEIGHTS } from '@cspeach/register-core';
+export const NOTHING_REPLANNED = 'Nothing has been re-planned. Lists follow the suggested order.';
+/** How many changes are listed before the rest is counted. */
+export const HISTORY_ROWS = 50;
+const PARTS = ['effort', 'risk', 'shared', 'usage', 'disposition'];
+const whole = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+function weightsHtml(plan) {
+    const w = plan?.weights ?? DEFAULT_WEIGHTS;
+    const source = plan?.weightsFrom === 'set'
+        ? (() => {
+            const day = dayWords(plan.weightsAt);
+            return `Set${plan.weightsBy ? ` by ${cell(plan.weightsBy)}` : ''}${day ? ` on ${esc(day)}` : ''}.`;
+        })()
+        : 'The default weights.';
+    return `<p class="plan-weights" data-role="weights">Priority weights: ${PARTS.map((p) => `${p} ${n(whole(w[p]))}`).join(', ')}. ${source}</p>`;
+}
+function focusStackHtml(focuses) {
+    if (!focuses.length)
+        return `<p class="quiet-note" data-role="no-focus">${esc(NO_FOCUS)}</p>`;
+    const item = (f) => {
+        const day = dayWords(f.at);
+        return `<li>${cell(f.label)} — ${n(whole(f.donePct))}% done, ${n(whole(f.proven))} of ${n(whole(f.active))} proven. `
+            + `Set by ${cell(f.by)}${day ? ` on ${esc(day)}` : ''}${f.reason ? ` because ${cell(f.reason)}` : ''}.</li>`;
+    };
+    return `<h3>The focus, in order</h3><ol class="focus-stack" data-role="focus-stack">${focuses.map(item).join('')}</ol>`;
+}
+function historyHtml(history) {
+    const shown = history.slice(0, HISTORY_ROWS);
+    const row = (c) => `<tr><td>${esc(formatWhen(c.at))}</td><td>${cell(c.by)}</td><td class="what">${cell(c.what)}</td>`
+        + `<td class="what">${c.why ? cell(c.why) : '<span class="quiet-note">no reason recorded</span>'}</td></tr>`;
+    const more = history.length - shown.length;
+    return '<h3>Changes, newest first</h3>'
+        + '<div class="scroller"><table data-role="plan-history" aria-label="Plan changes, newest first"><thead><tr>'
+        + '<th scope="col">When</th><th scope="col">Who</th><th scope="col">What</th><th scope="col">Why</th></tr></thead>'
+        + `<tbody>${shown.map(row).join('')}</tbody></table></div>`
+        + (more > 0 ? `<p class="quiet-note" data-role="plan-more">and ${n(more)} more</p>` : '');
+}
+/**
+ * The Plan and changes section's body.
+ * @param {object} register register-core `Register` (an older one with no `plan` reads as not re-planned)
+ * @returns {string} escaped markup
+ */
+export function planSectionHtml(register) {
+    const plan = register?.plan;
+    const history = Array.isArray(plan?.history) ? plan.history : [];
+    if (!history.length)
+        return `${weightsHtml(plan)}<p class="empty-note" data-role="plan-empty">${NOTHING_REPLANNED}</p>`;
+    return weightsHtml(plan) + focusStackHtml(Array.isArray(plan.focuses) ? plan.focuses : []) + historyHtml(history);
+}

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

@@ -0,0 +1,110 @@
+// @ts-nocheck
+// GENERATED COPY — do not edit here. Edit viewer/src/lib/progress-chart.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.
+/**
+ * Progress over time (spec 2026-10-06 §9 item 5).
+ *
+ * One small line chart a manager reads in one look: how many objects are
+ * decided, claimed, proven, and at level A, one point per check run. Drawn from
+ * register-core's `progress` series and nothing else, so the page, the status
+ * file and the workbook's Progress sheet all show the same counts.
+ *
+ * It lives under the page's strict policy and inside a mailed document, so it
+ * is plain inline SVG: no reference to anything outside itself, no style
+ * attribute (every colour and dash is a class in team.css), and every string
+ * escaped. Colour never stands alone: each line has its own dash, and the
+ * legend says the numbers in words.
+ *
+ * Under the chart, the done-% bars per lane and per focus — the same numbers
+ * the lane table and the focus line print. Bar widths are classes in 5 % steps
+ * (`w-0` … `w-100`), because a width written into the markup would be a style.
+ */
+import { esc } from './register-map.js';
+import { cell, dayWords, n, ownerLabel } from './register-parts.js';
+export const NO_RUN_YET = 'No check run yet, so there is no line to draw.';
+/** Back to front, so the line that matters most — proven — is drawn over the others. */
+const SERIES = [
+    { id: 'decided', label: 'Decided', of: (p) => p.decided },
+    { id: 'claimed', label: 'Claimed', of: (p) => p.claimed },
+    { id: 'proven', label: 'Proven', of: (p) => p.proven },
+    { id: 'a', label: 'At level A', of: (p) => p.aNow },
+];
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : 0);
+const fix = (v) => Number(v.toFixed(1));
+/** The width class for a percentage: nearest 5 % step, kept within 0 and 100. */
+export function pctClass(pct) {
+    const v = Number(pct);
+    if (!Number.isFinite(v) || v <= 0)
+        return 'w-0';
+    return `w-${Math.min(100, Math.round(v / 5) * 5)}`;
+}
+function legendHtml(points) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    const was = (s) => (points.length > 1 ? ` (${n(num(s.of(first)))} at the first run shown)` : '');
+    const item = (s) => {
+        const value = s.id === 'a' ? `${n(num(last.aNow))}, ${n(num(last.aShare))}% of active` : n(num(s.of(last)));
+        return `<li><span class="key key-${s.id}"></span>${esc(s.label)}: ${value}${was(s)}</li>`;
+    };
+    return `<ul class="chart-legend" data-role="progress-legend">${SERIES.map(item).join('')}</ul>`;
+}
+/**
+ * The chart as one figure: the SVG, the legend in words, what a point is, and —
+ * when register-core cut the series — how many runs are not shown.
+ *
+ * @param {object[]} points register-core `ProgressPoint[]`, oldest first
+ * @param {{ width?: number, height?: number, capped?: { shown: number, total: number } }} [opts]
+ * @returns {string} escaped markup
+ */
+export function progressChartSvg(points, { width = 640, height = 220, capped } = {}) {
+    if (!Array.isArray(points) || !points.length)
+        return `<p class="empty-note" data-role="no-progress">${NO_RUN_YET}</p>`;
+    const left = 44;
+    const right = 12;
+    const top = 12;
+    const bottom = 28;
+    const plotW = width - left - right;
+    const plotH = height - top - bottom;
+    const max = Math.max(1, ...points.map((p) => Math.max(num(p.active), ...SERIES.map((s) => num(s.of(p))))));
+    const x = (i) => fix(points.length === 1 ? left + plotW / 2 : left + (plotW * i) / (points.length - 1));
+    const y = (v) => fix(top + plotH - (plotH * num(v)) / max);
+    const ticks = [...new Set([0, max >= 4 ? Math.round(max / 2) : null, max].filter((t) => t !== null))];
+    const grid = ticks.map((t) => `<line class="grid" x1="${left}" x2="${width - right}" y1="${y(t)}" y2="${y(t)}"></line>`
+        + `<text class="axis" x="${left - 6}" y="${fix(y(t) + 4)}" text-anchor="end">${esc(n(t))}</text>`).join('');
+    const firstDay = dayWords(points[0].at);
+    const lastDay = dayWords(points[points.length - 1].at);
+    const base = height - 8;
+    const xLabels = points.length === 1
+        ? `<text class="axis" x="${x(0)}" y="${base}" text-anchor="middle">${esc(firstDay)}</text>`
+        : `<text class="axis" x="${left}" y="${base}" text-anchor="start">${esc(firstDay)}</text>`
+            + (lastDay && lastDay !== firstDay ? `<text class="axis" x="${width - right}" y="${base}" text-anchor="end">${esc(lastDay)}</text>` : '');
+    const lines = SERIES.map((s) => `<polyline class="pl pl-${s.id}" points="${points.map((p, i) => `${x(i)},${y(s.of(p))}`).join(' ')}"></polyline>`).join('');
+    // One run is a point, not a line: a polyline with one vertex draws nothing.
+    const dots = points.length === 1 ? SERIES.map((s) => `<circle class="pd pd-${s.id}" cx="${x(0)}" cy="${y(s.of(points[0]))}" r="3.5"></circle>`).join('') : '';
+    const last = points[points.length - 1];
+    const label = `Progress over time, ${points.length} point${points.length === 1 ? '' : 's'}: `
+        + SERIES.map((s) => `${s.label} ${num(s.of(last))}`).join(', ');
+    return '<figure class="progress-chart" data-role="progress-chart">'
+        + `<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="${esc(label)}">${grid}${lines}${dots}${xLabels}</svg>`
+        + `<figcaption>${legendHtml(points)}`
+        + '<p class="legend-line">Each point is a check run, oldest on the left. The A line counts the objects at level A. Lanes, scope and the focus are counted as they are now.</p>'
+        + (capped ? `<p class="legend-line" data-role="progress-capped">Showing the last ${n(num(capped.shown))} of ${n(num(capped.total))} check runs.</p>` : '')
+        + '</figcaption></figure>';
+}
+const barRow = (label, pct, proven, active, extra = '') => `<li><span class="pct-label">${label}</span> `
+    + `<span class="pct-bar"><span class="pct-fill${extra} ${pctClass(pct)}"></span></span>`
+    + `<span class="pct-n">${n(num(pct))}% · ${n(num(proven))} of ${n(num(active))} proven</span></li>`;
+/** How far each lane and each focus is now, as bars with the numbers beside them. */
+function doneBarsHtml(register) {
+    const lanes = (register.lanes ?? []).map((l) => barRow(cell(ownerLabel(l)), l.donePct, l.proven, l.active));
+    const focuses = (register.plan?.focuses ?? []).map((f) => barRow(`Focus: ${cell(f.label)}`, f.donePct, f.proven, f.active, ' f-focus'));
+    if (!lanes.length && !focuses.length)
+        return '';
+    return '<h3>Done now, per developer and focus</h3>'
+        + `<ul class="pct-bars" data-role="done-bars">${[...lanes, ...focuses].join('')}</ul>`;
+}
+/** The Progress over time section's body, as the page and the status file both draw it. */
+export function progressSectionHtml(register) {
+    return progressChartSvg(register.progress, { capped: register.progressCapped }) + doneBarsHtml(register);
+}

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

@@ -160,9 +160,14 @@ export function blockSvg(block, { cell = 10, gap = 2, role = 'group', colourBy =
         // A retired object keeps its state colour in level mode: the level counts
         // leave retired objects out, and a cell painted C that no count includes
         // would show a manager two numbers for one folder.
-        const asLevel = byLevel && o.state !== 'retired';
+        //
+        // A clean (or verified) object nobody decided has no level and nothing to
+        // decide: it keeps its state colour too, and its title says so — never
+        // "level not decided" (register-core leaves it out of the level counts).
+        const nothing = byLevel && o.inScope !== false && !o.decision && !LEVEL_SET.has(o.levelNow) && (o.state === 'clean' || o.state === 'verified');
+        const asLevel = byLevel && o.state !== 'retired' && !nothing;
         return `<rect class="cell ${asLevel ? levelClass(o.levelNow) : stateClass(o.state)}"${keyed ? ` data-key="${esc(o.key)}"` : ''} x="${x}" y="${y}" width="${cell}" height="${cell}" rx="2">`
-            + `<title>${esc(o.name)} · ${esc(o.type)}${asLevel ? ` · level ${esc(LEVEL_WORD[LEVEL_SET.has(o.levelNow) ? o.levelNow : 'none'])}` : ''} · ${esc(stateWord(o))}</title></rect>`;
+            + `<title>${esc(o.name)} · ${esc(o.type)}${asLevel ? ` · level ${esc(LEVEL_WORD[LEVEL_SET.has(o.levelNow) ? o.levelNow : 'none'])}` : nothing ? ' · clean, nothing to decide' : ''} · ${esc(stateWord(o))}</title></rect>`;
     }).join('');
     const label = `${block.package}: ${n.toLocaleString('en-US')} ${n === 1 ? 'object' : 'objects'}`;
     return `<svg class="block-map" role="${safeRole}" aria-label="${esc(label)}" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${rects}</svg>`;
@@ -200,13 +205,16 @@ export function legendHtml(byState, { unknown = 0 } = {}) {
  * @param {{ retired?: number }} [opts]
  * @returns {string}
  */
-export function levelLegendHtml(counts, { retired = 0 } = {}) {
+export function levelLegendHtml(counts, { retired = 0, nothingToDecide = 0 } = {}) {
     const entry = (cls, label, count) => `<li><span class="swatch ${cls}"></span>${esc(label)} <b>${esc((count ?? 0).toLocaleString('en-US'))}</b></li>`;
     // A folder from an older build has no level counts: say so, as the level bars
     // do, rather than print five zeros that read as "measured, nothing there".
     const items = counts
         ? LEVEL_BUCKETS.map((l) => entry(`l-${l}`, LEVEL_WORD[l], counts[l]))
         : ['<li>No levels recorded yet.</li>'];
+    // Drawn in the clean colour, the colour their cells keep (blockSvg).
+    if (counts && nothingToDecide > 0)
+        items.push(entry(stateClass('clean'), 'clean, nothing to decide', nothingToDecide));
     if (retired > 0)
         items.push(entry(stateClass('retired'), 'retired', retired));
     return `<ul class="legend">${items.join('')}</ul>`;

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

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

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

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