@cspeach/cli 1.1.30 → 1.1.32

package/dist/register/rules-edit.js

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

package/dist/register/status-file/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>`;