@cspeach/cli 1.1.29 → 1.1.31

package/dist/commands/team.js

@@ -18,12 +18,20 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { activeOf, buildRegister, narrowedLanes, objectKey, provenOf, } from '@cspeach/register-core';
+import { laneActiveOf, laneProvenOf, levelOf, normalizeRuleId, objectKey, } from '@cspeach/register-core';
 import { LOCAL_PACKAGE, listCustomPackages, pullBaseline, BaselineError } from '../register/baseline.js';
-import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, collectRecords, defaultOutboxDir, loadState, projectIdFor, readBaseline, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.js';
-import { measure, noVariantYetMessage, scopeLabel, scopeObjects, variantMismatchMessage, } from '../register/measure.js';
+import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, defaultOutboxDir, loadState, projectIdFor, readBaseline, readEstate, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.js';
+import { MAX_SECOND_PASS, measure, noVariantYetMessage, scopeLabel, scopeObjects, variantMismatchMessage, } from '../register/measure.js';
 import { measureFromFile, shown, upToFive } from '../register/atc-file.js';
-import { writeRecord } from '../register/records.js';
+import { writeLeadRecord, writeRecord } from '../register/records.js';
+import { findingsByObject } from '../register/findings.js';
+import { registerFor } from '../register/picture.js';
+import { HELD, combinedSheets, regenerateWorkingList, reportFileNames } from '../register/workbooks.js';
+import { writeXlsxFile } from '../register/xlsx.js';
+import { writeWhole } from '../register/write-whole.js';
+import { statusHtmlFor } from '../register/status-html.js';
+import { teamDiscover, evidenceRows, EVIDENCE_LINE, OUTSIDE_LINE } from './team-discover.js';
+import { focusCommand, laneChangeRecord, laneProposal, nowLine, planCommand, priorityCommand, reasonFrom } from './team-plan.js';
 const CLASSIFICATIONS = ['keep', 'fix', 'retire', 'redesign'];
 const TYPES = ['clean-core', 'upgrade', 'build'];
 /**
@@ -37,7 +45,16 @@ const TYPES = ['clean-core', 'upgrade', 'build'];
  * compares this with the lead's name, a ruling only counts when it comes from
  * the lead, and every record says who wrote it.
  */
-const whoAmI = (deps) => activeProject()?.name ?? deps.identity().name;
+export const whoAmI = (deps) => activeProject()?.name ?? deps.identity().name;
+/** After a record this laptop wrote: its working list, made again. One line, or none. */
+function refreshSheet(deps) {
+    const joined = activeProject();
+    if (!joined)
+        return;
+    const res = regenerateWorkingList(joined, whoAmI(deps), deps.now?.());
+    if (res.line)
+        deps.print(res.line);
+}
 /**
  * Names that are a machine's, not a person's. A team project whose lead is
  * "Admin" says nothing about who leads it, and the writer id, the rulings and
@@ -59,7 +76,7 @@ function looksLikeAMachine(name, deps) {
  * and a verb that passes it also gets `--name=Wave`, the spelling `refresh`
  * has always taken. The verbs that pass nothing read exactly as before.
  */
-function flags(args, flagOnly = []) {
+export function flags(args, flagOnly = []) {
     const positional = [];
     const opts = {};
     for (let i = 0; i < args.length; i++) {
@@ -82,7 +99,7 @@ function flags(args, flagOnly = []) {
     }
     return { positional, opts };
 }
-const list = (v) => (v ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+export const list = (v) => (v ?? '').split(',').map((s) => s.trim()).filter(Boolean);
 /** "1 object", "3 objects" — every count this command prints reads as a sentence. */
 const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
 /** `ZFI_*` style match, used only to expand --packages patterns against the real package list. */
@@ -95,15 +112,24 @@ export async function runTeamCommand(args, deps) {
     try {
         switch (sub) {
             case 'init': return await init(rest, deps);
+            case 'start': return await start(rest, deps);
             case 'join': return join(rest, deps);
-            case 'lane': return lane(rest, deps);
+            case 'lane': return await lane(rest, deps);
             case 'refresh': return await refresh(rest, deps);
             case 'status': return status(rest, deps);
             case 'outbox': return outbox(rest, deps);
             case 'rule': return rule(rest, deps);
             case 'leave': return leave(deps);
+            case 'decide': return decide(rest, deps);
+            case 'fixed': return await fixed(rest, deps);
+            case 'sheet': return sheet(deps);
+            case 'report': return report(rest, deps);
+            case 'discover': return await teamDiscover(rest, deps);
+            case 'focus': return focusCommand(rest, deps);
+            case 'priority': return priorityCommand(rest, deps);
+            case 'plan': return await planCommand(rest, deps);
             default:
-                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave   (cspeach --help for details)');
+                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave|decide|fixed|sheet|report|discover|focus|priority|plan|start   (cspeach --help for details)');
                 return sub ? 1 : 0;
         }
     }
@@ -112,16 +138,22 @@ export async function runTeamCommand(args, deps) {
             deps.print(`✗ ${e.message}`);
             return 1;
         }
-        throw e;
+        // Anything else (no SAP system configured, the connection refused, …) is one
+        // plain line too, never a stack trace (rehearsal 2026-10-07). CSPEACH_DEBUG=1
+        // still rethrows, so the trace is there when someone needs it.
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        deps.print(`✗ ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`);
+        return 1;
     }
 }
-function requireLead(project, deps) {
+export function requireLead(project, deps) {
     const me = whoAmI(deps);
     if (me.trim().toLowerCase() !== project.lead.name.trim().toLowerCase()) {
         throw new RegisterError(`Only the team project lead (${project.lead.name}) changes this. You are ${me}.`);
     }
 }
-function joinedOrThrow() {
+export function joinedOrThrow() {
     const joined = activeProject();
     if (!joined)
         throw new RegisterError('This laptop has not joined a team project. Run: cspeach team join <folder>');
@@ -129,11 +161,11 @@ function joinedOrThrow() {
 }
 // ── init ────────────────────────────────────────────────────────────────────
 const INIT_USAGE = 'Usage: cspeach team init <folder> --name "<name>" [--lead "<your name>"] [--type clean-core|upgrade|build] '
-    + '[--packages ZFI_*,ZSD_*] [--include-local] [--atc-variant <NAME>] [--no-measure]';
+    + '[--packages ZFI_*,ZSD_*] [--include-local] [--atc-variant <NAME>] [--no-measure] [--no-from-discovery]';
 /** Everything `init` understands. Anything else is a typo, and a typo is refused, never ignored. */
-const INIT_OPTIONS = ['name', 'lead', 'type', 'packages', 'include-local', 'sap-alias', 'atc-variant', 'no-measure'];
+const INIT_OPTIONS = ['name', 'lead', 'type', 'packages', 'include-local', 'sap-alias', 'atc-variant', 'no-measure', 'from-discovery', 'no-from-discovery'];
 /** The two that take no value, so neither can eat the folder name. */
-const INIT_FLAGS = ['include-local', 'no-measure'];
+const INIT_FLAGS = ['include-local', 'no-measure', 'from-discovery', 'no-from-discovery'];
 /** Typed on `init` out of muscle memory: they choose what to MEASURE, which is another verb. */
 const REFRESH_ONLY = ['all', 'lane', 'force-variant', 'chunk', 'max-minutes', 'no-one-by-one', 'from-file', 'absent-means-clean'];
 /**
@@ -159,6 +191,60 @@ function unknownInitOption(name) {
         return said;
     return `${said} Did you mean --${guess}?`;
 }
+const START_USAGE = 'Usage: cspeach team start <packages> [--name "<name>"] [--atc-variant <NAME>] [--folder <folder>] [--no-measure] [--sap-alias <name>]';
+const START_OPTIONS = ['name', 'atc-variant', 'folder', 'no-measure', 'sap-alias'];
+/** The check a project measures with when nobody names one. */
+export const DEFAULT_ATC_VARIANT = 'ABAP_CLOUD_READINESS';
+/**
+ * 1.1.31 (owner, 2026-10-07: "why doesn't CSPeach remember all that?") — one
+ * command for what init + join + lane add said in three: the folder you are
+ * in, a name from the packages, you as the lead, the default check, your
+ * results straight into the folder, and every object yours. The long verbs
+ * stay for big team setups.
+ */
+async function start(args, deps) {
+    const { positional, opts } = flags(args, ['no-measure']);
+    for (const name of Object.keys(opts)) {
+        if (!START_OPTIONS.includes(name))
+            throw new RegisterError(`--${name} is not an option of team start.\n${START_USAGE}`);
+    }
+    const packages = positional.join(',').split(',').map((p) => p.trim().toUpperCase()).filter(Boolean);
+    if (!packages.length)
+        throw new RegisterError(START_USAGE);
+    const dir = path.resolve(opts.folder && opts.folder !== 'true' ? opts.folder : process.cwd());
+    if (fs.existsSync(path.join(dir, TEAM_FILE)))
+        throw new RegisterError('This folder already holds a team project. Start a new one in an empty folder, or carry on with this one.');
+    const lead = deps.identity().name;
+    const name = opts.name && opts.name !== 'true' ? opts.name : packages.join(', ');
+    const variant = opts['atc-variant'] && opts['atc-variant'] !== 'true' ? opts['atc-variant'] : DEFAULT_ATC_VARIANT;
+    // The three verbs run as they always do; their detail is kept back and the
+    // few lines that matter are said once, below.
+    const said = [];
+    const quiet = { ...deps, print: (l) => said.push(l) };
+    const initArgs = [dir, '--name', name, '--lead', lead, '--packages', packages.join(','), '--atc-variant', variant,
+        ...(opts['no-measure'] ? ['--no-measure'] : []), ...(opts['sap-alias'] && opts['sap-alias'] !== 'true' ? ['--sap-alias', opts['sap-alias']] : [])];
+    const code = await init(initArgs, quiet);
+    if (code !== 0) {
+        for (const l of said)
+            deps.print(l);
+        return code;
+    }
+    join([dir, '--outbox', dir], quiet);
+    const laneId = (lead.trim().split(/\s+/)[0] ?? '').toLowerCase().replace(/[^a-z0-9]/g, '') || 'me';
+    await lane(['add', laneId, '--owner', lead, '--packages', packages.join(',')], quiet);
+    const pulled = said.map((l) => /: (\d+) objects? in \d+ packages?\. Every package matched/.exec(l)).find(Boolean);
+    const measured = said.map((l) => /^✓ (\d+) objects? measured, (\d+) with findings/.exec(l)).find(Boolean);
+    const objects = pulled ? Number(pulled[1]) : readBaseline(dir).length;
+    deps.print(`✓ Started "${name}" in this folder. Lead: ${lead}.`);
+    deps.print(`  ${plural(objects, 'object', 'objects')}, matched against the system's own count.`);
+    if (measured)
+        deps.print(`  First check (${variant.toUpperCase()}): ${measured[2]} of ${measured[1]} objects with findings.`);
+    else if (opts['no-measure'])
+        deps.print('  No check run yet: cspeach team refresh measures it.');
+    deps.print(`  You own all ${plural(objects, 'object', 'objects')}. Your results go straight into this folder.`);
+    deps.print(`  Next, in CSPeach: /abap-clean-core triage lane ${laneId}`);
+    return 0;
+}
 async function init(args, deps) {
     const { positional, opts } = flags(args, INIT_FLAGS);
     // `--no-measur` must not read as "measure anyway": a person who meant to skip
@@ -191,6 +277,11 @@ async function init(args, deps) {
         throw new RegisterError(`"${opts['atc-variant'].trim()}" is not an ATC check variant name.`);
     if (!deps.connect)
         throw new RegisterError('init needs a SAP connection to pull the object list.');
+    if (opts['from-discovery'] && opts['no-from-discovery'])
+        throw new RegisterError(`Say --from-discovery or --no-from-discovery, not both.
+${INIT_USAGE}`);
+    // The newest discovery in this folder, when there is one and it is not turned off (spec 2026-10-06 §7).
+    const discovery = opts['no-from-discovery'] ? null : readEstate(dir);
     const { sql, system, atc } = await deps.connect(opts['sap-alias']);
     deps.print('Reading the package list from SAP…');
     const all = await listCustomPackages(sql);
@@ -206,6 +297,9 @@ async function init(args, deps) {
     if (!chosen.length) {
         throw new RegisterError(`No package chosen. ${all.length} customer packages exist; name them with --packages, e.g. --packages "ZFI_*,ZSD_*".`);
     }
+    if (discovery)
+        for (const l of estatePackageLines(chosen, discovery.estate))
+            deps.print(l);
     deps.print(`Pulling ${chosen.length} package${chosen.length === 1 ? '' : 's'}, checking each against the system's own count…`);
     const pull = await pullBaseline(sql, { packages: chosen });
     if (!pull.objects.length)
@@ -225,9 +319,14 @@ async function init(args, deps) {
     fs.writeFileSync(path.join(dir, BASELINE_FILE), baselineText);
     fs.writeFileSync(path.join(dir, TEAM_FILE), `${JSON.stringify(project, null, 2)}\n`);
     writeLanes(dir, projectId, []);
+    const evidenceLines = discovery || opts['from-discovery']
+        ? firstEvidence(dir, projectId, pull.objects, discovery, { name: lead, writer: writerIdFor(given || deps.identity().name, deps.machine?.()) }, now, deps)
+        : [];
     deps.print(`✓ ${name}: ${pull.objects.length} objects in ${chosen.length} packages. Every package matched the system's count.`);
     deps.print(`  Set aside, not in scope: ${project.setAside.local} customer-named local ($TMP) entries of any type, ${pull.setAside.generated} generated, ${pull.setAside.otherTypes} non-code entries.`);
     deps.print(`  Written to ${dir}`);
+    for (const l of evidenceLines)
+        deps.print(l);
     // F4: the live run of 2026-09-20 recorded the lead as "Admin" — the Windows
     // user. That name goes into the team project file, into the writer id and
     // into every record from then on. Said once, never asked.
@@ -253,6 +352,62 @@ async function init(args, deps) {
         deps.print(l);
     return 0;
 }
+/**
+ * Per chosen package, what the estate knows beside the live count: its
+ * description, application area and last change. Packages the estate does
+ * not hold get the count alone.
+ */
+function estatePackageLines(chosen, estate) {
+    const known = new Map();
+    const pkgs = estate?.packages;
+    if (Array.isArray(pkgs))
+        for (const p of pkgs)
+            if (p && typeof p.name === 'string')
+                known.set(p.name, p);
+    return chosen.map((c) => {
+        const p = known.get(c.package);
+        const text = (v) => (typeof v === 'string' ? v.trim().slice(0, 300) : '');
+        const parts = [plural(c.objects, 'object', 'objects')];
+        if (p) {
+            if (text(p.text))
+                parts.push(text(p.text));
+            if (text(p.area))
+                parts.push(`area ${text(p.area)}`);
+            const at = text(p.lastChanged?.at);
+            if (at)
+                parts.push(`last changed ${at}${text(p.lastChanged?.by) ? ` by ${text(p.lastChanged.by)}` : ''}`);
+        }
+        return `  ${c.package}: ${parts.join(' · ')}`;
+    });
+}
+/**
+ * baseline/evidence-0.json (spec 2026-10-06 §7): the inventory's evidence for
+ * the team project's own objects, from the newest object list. Rows for other
+ * objects are never written; they are counted. Never fails `init`: the team
+ * project is complete without it.
+ */
+function firstEvidence(dir, projectId, baseline, discovery, by, now, deps) {
+    if (!discovery)
+        return ['  No discovery in this folder, so no evidence was written. Run: cspeach team discover --out <folder>'];
+    const ev = evidenceRows(discovery.objects, new Set(baseline.map((o) => objectKey(o.type, o.name))));
+    if (!ev)
+        return ['  The object list of the inventory could not be read, so no evidence was written.'];
+    try {
+        const file = `objects-${discovery.stamp}.json`;
+        let sum = '';
+        try {
+            sum = sha256(fs.readFileSync(path.join(dir, 'discovery', file), 'utf8'));
+        }
+        catch { /* the checksum is a nicety */ }
+        writeLeadRecord(path.join(dir, 'baseline'), projectId, 'evidence', { source: { file, sha256: sum } }, ev.rows, by, { now, fileName: 'evidence-0.json', ...(deps.rand ? { rand: deps.rand } : {}) });
+    }
+    catch (e) {
+        // Node's own message carries the full path, user name and all; the code says enough.
+        const code = e?.code;
+        return [`  ! The inventory's evidence could not be written${code ? ` (${code})` : ''}. The team project itself is complete.`];
+    }
+    return [`  ${EVIDENCE_LINE(ev.rows.length)}`, ...(ev.outside ? [`  ${OUTSIDE_LINE(ev.outside)}`] : [])];
+}
 /** Errors that are about this laptop's disk or the shared folder, never about SAP. */
 const CANNOT_WRITE = new Set(['EPERM', 'EACCES', 'EROFS', 'ENOSPC', 'EISDIR', 'ENOTEMPTY', 'EBUSY', 'EMFILE', 'ENOTDIR']);
 /**
@@ -298,6 +453,7 @@ async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
         const res = await measure({
             joined: joinedOrThrow(), project, baseline, lanes: [], scope: { kind: 'all' }, variant, atc, by: { name: whoAmI(deps) },
             dir: path.join(dir, 'baseline'), fileName: 'measurement-0.json',
+            confirmAbsent: true,
             ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
             signal: stop.signal,
             onProgress: progressLine(deps),
@@ -312,7 +468,7 @@ async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
         // line: this one record belongs to the team project, not to this laptop.
         if (res.file)
             deps.print('  This first measurement is part of the team project\'s baseline, in the shared folder.');
-        const stoppedBy = res.stoppedBy ?? (stop.signal.aborted ? 'aborted' : undefined);
+        const stoppedBy = res.stoppedBy ?? secondPassStop(res) ?? (stop.signal.aborted ? 'aborted' : undefined);
         if (stoppedBy) {
             const why = STOPPED_WORDS[stoppedBy];
             deps.print(res.file
@@ -356,6 +512,11 @@ function join(args, deps, asName) {
     state.active = project.projectId;
     saveState(state);
     deps.print(`✓ Joined "${project.name}" (${objects} objects, lead ${project.lead.name}) as ${writerId}.`);
+    // Outbox is the team project folder itself: records land where everyone reads them.
+    if (path.relative(projectDir, outboxDir) === '') {
+        deps.print('  Your results are written straight into the team project folder, under writers. Nothing to hand in.');
+        return 0;
+    }
     deps.print(`  Your own results are recorded on this laptop, in ${outboxDir}`);
     deps.print('  CSPeach does not send them anywhere. Hand them in by copying that folder\'s "writers" folder into the team project folder,');
     deps.print('  or keep the outbox inside your own synced folder: cspeach team join <folder> --outbox <folder>');
@@ -374,8 +535,10 @@ function leave(deps) {
     return 0;
 }
 // ── lane ────────────────────────────────────────────────────────────────────
-function lane(args, deps) {
+async function lane(args, deps) {
     const [verb, ...rest] = args;
+    if (verb === 'propose')
+        return laneProposal(rest, deps);
     const { positional, opts } = flags(rest);
     const joined = joinedOrThrow();
     const project = readProjectFile(joined.projectDir);
@@ -390,14 +553,20 @@ function lane(args, deps) {
     requireLead(project, deps);
     const id = positional[0];
     if (!id)
-        throw new RegisterError('Usage: cspeach team lane add <id> --owner "<name>" --packages "ZFI_*" [--names "ZCL_TAX_*"]  |  lane remove <id>');
+        throw new RegisterError('Usage: cspeach team lane add <id> --owner "<name>" --packages "ZFI_*" [--names "ZCL_TAX_*"] [--reason "<why>"]  |  lane remove <id> [--reason "<why>"]  |  lane propose --developers "…"');
+    const reason = reasonFrom(opts, false);
     if (verb === 'remove') {
         writeLanes(joined.projectDir, project.projectId, lanes.filter((l) => l.id !== id));
         deps.print(`✓ Lane ${id} removed.`);
+        const was = lanes.find((l) => l.id === id);
+        // With a reason, the change is also kept in the plan history; without one,
+        // `lane remove` says and writes exactly what it always did.
+        if (was && reason)
+            deps.print(laneChangeRecord(deps, 'remove', was, undefined, id, reason));
         return 0;
     }
     if (verb !== 'add')
-        throw new RegisterError('lane: use add, remove or list.');
+        throw new RegisterError('lane: use add, remove, list or propose.');
     const next = { id, owner: opts.owner ?? '', packages: list(opts.packages), namePatterns: list(opts.names) };
     if (!next.owner || (!next.packages.length && !next.namePatterns.length)) {
         throw new RegisterError('A lane needs --owner and at least one of --packages or --names.');
@@ -415,27 +584,11 @@ function lane(args, deps) {
         deps.print(`  ! ${plural(reg.register.totals.overlapping, 'object now sits', 'objects now sit')} in more than one lane.`);
     if (reg.register.totals.unowned)
         deps.print(`  ${plural(reg.register.totals.unowned, 'object still has', 'objects still have')} no owner.`);
+    if (reason)
+        deps.print(laneChangeRecord(deps, 'add', lanes.find((l) => l.id === id), next, id, reason));
     return 0;
 }
 // ── status ──────────────────────────────────────────────────────────────────
-function registerFor(projectDir, outboxDir) {
-    const project = readProjectFile(projectDir);
-    const collected = collectRecords(projectDir);
-    // This laptop's own outbox counts too, so a developer sees their work before
-    // handing it in. It is also the one way this picture can legitimately differ
-    // from the team project page's, so `status` says out loud when it counted them.
-    const own = outboxDir && path.resolve(outboxDir) !== path.resolve(projectDir) ? collectRecords(outboxDir) : { records: [], unreadable: 0, files: 0 };
-    const baseline = readBaseline(projectDir);
-    const lanes = readLanes(projectDir);
-    const register = buildRegister({ project, baseline, lanes, records: [...collected.records, ...own.records] });
-    return {
-        register, files: collected.files + own.files,
-        unreadable: collected.unreadable + own.unreadable, ownFiles: own.files,
-        // F2: a lanes.json written before names began to narrow packages holds
-        // fewer objects now. The lead is told, not left to work it out from a count.
-        narrowed: narrowedLanes(lanes, baseline),
-    };
-}
 const STATE_WORDS = [
     ['verified', 'verified'], ['clean', 'clean'], ['claimed', 'claimed, not measured since'], ['working', 'in work'],
     ['decided', 'decided, not started'], ['untouched', 'untouched'], ['did-not-hold', 'fix did not hold'],
@@ -451,11 +604,21 @@ function status(args, deps) {
     const { register: r, files, unreadable, ownFiles, narrowed } = registerFor(projectDir, positional[0] ? undefined : joined?.outboxDir);
     const t = r.totals;
     deps.print(`${project.name}  (${project.type}, lead ${project.lead.name})`);
+    // The estate around the team project, when the folder holds a discovery (spec 2026-10-06 §9).
+    if (r.estate) {
+        const e = r.estate.totals;
+        const n = (v) => v.toLocaleString('en-US');
+        deps.print(`Estate: ${n(e.packages)} ${e.packages === 1 ? 'package' : 'packages'}, `
+            + `${n(e.codeObjects)} programs and other code objects, ${n(e.nonCodeObjects)} non-code objects, `
+            + `${n(e.unknowns)} ${e.unknowns === 1 ? 'unknown' : 'unknowns'}`);
+    }
     // A clean sheet out of a file is somebody's export, not this system speaking.
     // The words "verified" and "clean" do not change; the line says how many of
     // them were measured one step removed, so nobody reads them as live proof.
     const fromFile = t.fromFile.verified + t.fromFile.clean;
+    // Recording fix 4: a clean object nobody decided has nothing to decide — said on its own.
     deps.print(`${t.objects} objects, ${t.active} active. ${t.decided} decided. `
+        + `${t.cleanNothingToDecide ? `${t.cleanNothingToDecide} clean, nothing to decide. ` : ''}`
         + `${t.byState.verified} verified, ${t.byState.clean} clean`
         + `${fromFile ? ` — ${fromFile} of them measured from a file` : ''}.`);
     // The newest run that counted — by its time, not by the order the files were
@@ -464,6 +627,7 @@ function status(args, deps) {
     deps.print(r.lastMeasuredAt
         ? `Last measured ${r.lastMeasuredAt.slice(0, 16).replace('T', ' ')} UTC${lastRun?.basis === 'file' ? ', from a file' : ''}.`
         : 'Not measured yet: "verified" and "clean" need an ATC run.');
+    deps.print(nowLine(r));
     deps.print('');
     for (const [state, word] of STATE_WORDS)
         if (t.byState[state])
@@ -476,9 +640,15 @@ function status(args, deps) {
         deps.print(`${'Lane'.padEnd(12)} ${'Owner'.padEnd(20)} Objects Active Proven  Last record`);
         for (const l of r.lanes) {
             deps.print(`${l.id.padEnd(12)} ${l.owner.padEnd(20)} ${String(l.objects).padStart(7)} `
-                + `${String(activeOf(l.objects, l.byState)).padStart(6)} ${String(provenOf(l.byState)).padStart(6)}  `
+                + `${String(laneActiveOf(l)).padStart(6)} ${String(laneProvenOf(l)).padStart(6)}  `
                 + `${l.lastRecordAt ? l.lastRecordAt.slice(0, 10) : 'nothing yet'}`);
         }
+        // Done and what comes next, by the same priority every surface sorts by.
+        // Names only: a lane id stands only beside its owner's name.
+        for (const l of r.lanes) {
+            const next = l.next.slice(0, 3).map((k) => k.slice(k.indexOf('|') + 1));
+            deps.print(`  ${l.owner} (${l.id}): Done ${l.donePct}%. Next: ${next.length ? next.join(', ') : 'nothing left to prove'}`);
+        }
         // Said once per lane it is true of. A lane set up before this rule held
         // both a package list and a name list, and took the whole package.
         for (const id of narrowed)
@@ -489,6 +659,10 @@ function status(args, deps) {
         deps.print(`! ${plural(t.unowned, 'object has', 'objects have')} no owner.`);
     if (t.overlapping)
         deps.print(`! ${plural(t.overlapping, 'object sits', 'objects sit')} in more than one lane.`);
+    if (t.retireCandidates)
+        deps.print(`${plural(t.retireCandidates, 'retire candidate waits', 'retire candidates wait')} for the lead.`);
+    if (t.outOfScope)
+        deps.print(`${plural(t.outOfScope, 'object', 'objects')} out of scope.`);
     if (t.conflicts) {
         deps.print(`! ${plural(t.conflicts, 'object has a conflicting decision', 'objects have conflicting decisions')}.`
             + ` The lead settles ${t.conflicts === 1 ? 'it' : 'each'} with: cspeach team rule <TYPE> <NAME> <decision>`);
@@ -544,6 +718,7 @@ const sameText = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
  */
 export const REFRESH_USAGE = 'Usage: cspeach team refresh (--lane <id> | --packages "ZFI_*,ZSD_*" | --all) '
     + '[--variant <NAME>] [--force-variant] [--chunk <n>] [--max-minutes <n>] [--no-one-by-one] [--sap-alias <name>]\n'
+    + '   or: cspeach team refresh (--all | --packages "ZFI_*,ZSD_*") --per-package [--again] [--variant <NAME>]\n'
     + '   or: cspeach team refresh --from-file <file.csv> [--lane <id> | --packages "ZFI_*,ZSD_*" | --all] '
     + '[--variant <NAME>] [--absent-means-clean]';
 /** Options that take a value, with the example each refusal shows. */
@@ -556,7 +731,7 @@ const VALUE_OPTIONS = {
     'sap-alias': '--sap-alias S4H',
     'from-file': '--from-file atc-export.csv',
 };
-const FLAG_OPTIONS = ['all', 'force-variant', 'no-one-by-one', 'absent-means-clean'];
+const FLAG_OPTIONS = ['all', 'force-variant', 'no-one-by-one', 'absent-means-clean', 'per-package', 'again'];
 const KNOWN_OPTIONS = [...Object.keys(VALUE_OPTIONS), ...FLAG_OPTIONS];
 /** Options that describe a check RUN. A file was made by a run that is already over. */
 const RUN_ONLY_OPTIONS = ['chunk', 'max-minutes', 'no-one-by-one', 'sap-alias'];
@@ -646,6 +821,11 @@ export function parseRefreshArgs(args) {
     }
     const given = ['all', 'lane', 'packages'].filter((k) => opts[k] !== undefined);
     const fromFile = opts['from-file'];
+    if (opts['per-package'] !== undefined && (fromFile !== undefined || opts.lane !== undefined)) {
+        return no('--per-package goes with --all or --packages: it measures one package at a time.');
+    }
+    if (opts.again !== undefined && opts['per-package'] === undefined)
+        return no('--again only goes with --per-package.');
     if (fromFile === undefined) {
         if (given.length !== 1)
             return no('Say what to measure, one of: --lane <id>   --packages "ZFI_*,ZSD_*"   --all');
@@ -689,6 +869,8 @@ export function parseRefreshArgs(args) {
         oneByOne: opts['no-one-by-one'] === undefined,
         absentMeansClean: opts['absent-means-clean'] !== undefined,
         ...(fromFile !== undefined ? { fromFile: fromFile.trim() } : {}),
+        ...(opts['per-package'] !== undefined ? { perPackage: true } : {}),
+        ...(opts.again !== undefined ? { again: true } : {}),
     };
     if (opts.variant !== undefined) {
         const variant = opts.variant.trim().toUpperCase();
@@ -805,9 +987,49 @@ export const absentLine = (count, names) => [
         + `${count === 1 ? 'It is' : 'They are'} left as not measured.`,
     ...(names.length ? [`    ${someNames(names)}`] : []),
 ];
+/**
+ * R-1, said plainly: how many silent objects were checked again on their own,
+ * and — for the ones that were not — the true reason. An object the second pass
+ * skipped or never finished gets THIS reason, never the variant's.
+ */
+function secondPassLines(res, deps) {
+    const pass = res.secondPass;
+    if (!pass)
+        return;
+    if (pass.asked) {
+        deps.print(`  ${plural(pass.asked, 'object the run did not list was', 'objects the run did not list were')} checked again on `
+            + `${pass.asked === 1 ? 'its' : 'their'} own: ${pass.listed} listed.`);
+    }
+    const n = pass.notChecked ?? 0;
+    const own = n === 1 ? 'on its own and stays' : 'on their own and stay';
+    if (pass.stopped) {
+        const why = STOPPED_WORDS[pass.stopped];
+        deps.print(n
+            ? `  ! Checking those objects one by one ${why} before it finished: ${plural(n, 'object was', 'objects were')} not checked again ${own} not measured.`
+            : `  ! Checking those objects one by one ${why} before it finished.`);
+    }
+    else if (n) {
+        deps.print(`  ! ${plural(n, 'object was', 'objects were')} not checked again: ${n === 1 ? 'its own check' : 'their own checks'} did not finish. `
+            + `${n === 1 ? 'It stays' : 'They stay'} not measured.`);
+    }
+    if (pass.skipped && pass.skippedBy === 'time') {
+        deps.print(`  ! ${plural(pass.skipped, 'object the run did not list was', 'objects the run did not list were')} not checked again on `
+            + `${pass.skipped === 1 ? 'its' : 'their'} own: the time budget ran out first. ${pass.skipped === 1 ? 'It stays' : 'They stay'} not measured.`);
+    }
+    else if (pass.skipped) {
+        deps.print(`  ! ${plural(pass.skipped, 'more object was', 'more objects were')} not checked again `
+            + `(one measurement checks up to ${MAX_SECOND_PASS} on their own). Narrow the run with --lane or --packages to check the rest.`);
+    }
+    if ((n || pass.skipped) && res.notCheckedNames?.length)
+        deps.print(`    ${someNames(res.notCheckedNames)}`);
+}
 function notMeasuredLines(res, deps, words = {}) {
-    if (res.absent) {
-        for (const line of words.absentLines?.(res.absent) ?? absentLine(res.absent, res.absentNames))
+    // Objects the second pass skipped or never finished were said above, with
+    // their own reason. Only the rest are the variant's silence.
+    const unchecked = new Set(res.notCheckedNames ?? []);
+    const silent = Math.max(0, res.absent - (res.secondPass?.skipped ?? 0) - (res.secondPass?.notChecked ?? 0));
+    if (silent) {
+        for (const line of words.absentLines?.(silent) ?? absentLine(silent, res.absentNames.filter((k) => !unchecked.has(k))))
             deps.print(line);
     }
     for (const c of res.refusedChunks) {
@@ -826,10 +1048,12 @@ export function reportMeasurement(res, variant, deps, foreignTo, words = {}) {
         deps.print(words.nothing ?? '✗ Nothing was measured, so nothing was written.');
         for (const note of words.notes ?? [])
             deps.print(note);
+        secondPassLines(res, deps);
         notMeasuredLines(res, deps, words);
         return;
     }
     deps.print(words.headline ?? `✓ ${plural(res.measured, 'object measured', 'objects measured')}, ${res.withFindings} with findings.`);
+    secondPassLines(res, deps);
     // F3: SAP reports some findings twice — same place, same message, two finding
     // ids. One problem in the code is one finding, so it is counted once; a
     // person comparing this with their own ATC screen has to be told why the two
@@ -850,6 +1074,11 @@ export function reportMeasurement(res, variant, deps, foreignTo, words = {}) {
     deps.print(`  Written to ${res.file}`);
     deps.print('  Next: cspeach team status');
 }
+/**
+ * A second pass that was cut short, or never had time to start, leaves objects
+ * not checked again: the measurement is partial, and the exit code says so.
+ */
+const secondPassStop = (res) => res.secondPass?.stopped ?? (res.secondPass?.skippedBy === 'time' && res.secondPass.skipped ? 'deadline' : undefined);
 /** Why a run ended before it reached the end of the set, in plain words. */
 const STOPPED_WORDS = {
     deadline: 'ran out of time',
@@ -881,7 +1110,7 @@ function stillStanding(register, absentNames) {
  * `once`, on purpose: the SECOND press is Node's own, so a request that has
  * hung can always be quit.
  */
-function onInterrupt(deps, stop) {
+export function onInterrupt(deps, stop) {
     if (deps.onInterrupt)
         return deps.onInterrupt(stop);
     const handler = () => stop();
@@ -998,6 +1227,7 @@ function refreshFromFile(opts, deps) {
     });
     if (!res.file)
         return 1;
+    refreshSheet(deps);
     // Live evidence outranks file evidence, per object. An import that changes no
     // state is legal and is kept — but nobody should have to work that out from
     // the picture afterwards, and no closing line may read as a fresh measurement.
@@ -1020,6 +1250,16 @@ async function refresh(args, deps) {
         deps.print(CANNOT_MEASURE);
         return 2;
     }
+    // 1.1.31: no scope said → your own lane, when you own exactly one.
+    if (!args.some((a) => /^--(all|lane|packages|from-file)(=|$)/.test(a))) {
+        const joinedNow = activeProject();
+        if (joinedNow) {
+            const me = whoAmI(deps).trim().toLowerCase();
+            const mine = readLanes(joinedNow.projectDir).filter((l) => l.owner.trim().toLowerCase() === me);
+            if (mine.length === 1)
+                args = [...args, '--lane', mine[0].id];
+        }
+    }
     const parsed = parseRefreshArgs(args);
     if (!parsed.ok)
         throw new RegisterError(parsed.message);
@@ -1057,6 +1297,8 @@ async function refresh(args, deps) {
         deps.print(CANNOT_MEASURE);
         return 2;
     }
+    if (opts.perPackage)
+        return refreshPerPackage({ joined, project, baseline, lanes, inScope, variant, foreign, persist, atc, opts }, deps);
     deps.print(`Measuring ${scopeWords(scope)} with ${variant}: ${plural(inScope.length, 'object', 'objects')}.`);
     const stop = new AbortController();
     const off = onInterrupt(deps, () => {
@@ -1079,6 +1321,7 @@ async function refresh(args, deps) {
             // the lead's first run, whose name is not on disk yet.
             ...(foreign || persist ? { forceVariant: true } : {}),
             signal: stop.signal,
+            confirmAbsent: true,
             onProgress: progressLine(deps),
         });
     }
@@ -1086,6 +1329,8 @@ async function refresh(args, deps) {
         off();
     }
     reportMeasurement(res, variant, deps, foreign ? (project.atcVariant ?? '').trim().toUpperCase() : undefined);
+    if (res.file)
+        refreshSheet(deps);
     // The picture, once, for the two things said after the report. Built lazily:
     // a refresh that measured nothing and reported nothing does not need it.
     let merged = null;
@@ -1111,7 +1356,7 @@ async function refresh(args, deps) {
                 + `Ask the lead to try again: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
-    const stoppedBy = res.stoppedBy ?? (stop.signal.aborted ? 'aborted' : undefined);
+    const stoppedBy = res.stoppedBy ?? secondPassStop(res) ?? (stop.signal.aborted ? 'aborted' : undefined);
     if (stoppedBy) {
         const why = STOPPED_WORDS[stoppedBy];
         deps.print(res.file
@@ -1129,6 +1374,117 @@ async function refresh(args, deps) {
     }
     return 0;
 }
+/**
+ * D6: the estate measured one package at a time, one measurement record each,
+ * through the same `measure()` as every run. A package that already has a
+ * counted record of this variant for exactly its own scope is skipped unless
+ * `--again`, so a long estate run can be stopped and taken up again. Ctrl-C
+ * stops between packages; every record already written stays.
+ */
+async function refreshPerPackage(input, deps) {
+    const { joined, project, baseline, lanes, inScope, variant, foreign, persist, atc, opts } = input;
+    const packages = [...new Set(inScope.map((o) => o.package))].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const labelOf = (pkg) => scopeLabel({ kind: 'packages', patterns: [pkg] });
+    // A package is done only when a counted run from the system (never a result file),
+    // with this variant and this package as its scope, says it reached every object:
+    // nothing failed, nothing left not run. A run cut short by Ctrl-C, the deadline or
+    // a lost connection wrote a partial record, and that package is measured again.
+    const done = new Set();
+    if (!opts.again) {
+        for (const run of registerFor(joined.projectDir, joined.outboxDir).register.runs) {
+            if ((run.atcVariant ?? '').trim().toUpperCase() !== variant || !run.scope || run.basis !== 'system')
+                continue;
+            const c = run.coverage;
+            // notRun must be said and be 0: a record that does not say is not proof the run got everywhere.
+            if (c && c.asked > 0 && c.failed === 0 && c.notRun === 0
+                && c.measured + (c.unsupported ?? 0) + (c.absent ?? 0) >= c.asked)
+                done.add(run.scope);
+        }
+    }
+    const todo = packages.filter((p) => !done.has(labelOf(p)));
+    const skipped = packages.length - todo.length;
+    if (skipped) {
+        deps.print(`Skipped ${plural(skipped, 'package', 'packages')} already measured (use --again to measure ${skipped === 1 ? 'it' : 'them'} again).`);
+    }
+    if (!todo.length)
+        return 0;
+    deps.print(`Measuring ${plural(todo.length, 'package', 'packages')} one at a time with ${variant}. Ctrl-C stops between packages and keeps what is written.`);
+    // Ctrl-C is checked between packages, never handed into a package's run: a package
+    // is measured whole or not at all. (A deadline or a lost connection can still cut a
+    // package short; its record then shows it, and the next run measures it again.)
+    const stop = new AbortController();
+    const off = onInterrupt(deps, () => {
+        if (stop.signal.aborted)
+            return;
+        deps.print('  Stopping after this package. What has already been measured will still be written.');
+        deps.print('  Press Ctrl-C again to quit now.');
+        stop.abort();
+    });
+    let measuredPackages = 0;
+    let written = 0;
+    let variantSaved = false;
+    let lostConnection = false;
+    try {
+        for (const pkg of todo) {
+            if (stop.signal.aborted)
+                break;
+            const objects = inScope.filter((o) => o.package === pkg).length;
+            deps.print(`${pkg}: ${plural(objects, 'object', 'objects')}…`);
+            const res = await measure({
+                joined, project, baseline, lanes, scope: { kind: 'packages', patterns: [pkg] }, variant, atc, by: { name: whoAmI(deps) },
+                ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
+                ...(opts.chunkSize ? { chunkSize: opts.chunkSize } : {}),
+                ...(opts.maxTotalMs ? { maxTotalMs: opts.maxTotalMs } : {}),
+                ...(opts.oneByOne ? {} : { oneByOne: false }),
+                ...(foreign || persist ? { forceVariant: true } : {}),
+                confirmAbsent: true,
+                onProgress: progressLine(deps),
+            });
+            measuredPackages += 1;
+            if (res.file) {
+                written += 1;
+                deps.print(`  ✓ ${pkg}: ${plural(res.measured, 'object measured', 'objects measured')}, ${res.withFindings} with findings. Written: ${path.basename(res.file)}`);
+            }
+            else {
+                deps.print(`  ✗ ${pkg}: nothing was measured, so nothing was written.`);
+            }
+            secondPassLines(res, deps);
+            notMeasuredLines(res, deps);
+            if (res.file && persist && !variantSaved) {
+                try {
+                    writeProjectVariant(joined.projectDir, variant);
+                    variantSaved = true;
+                    deps.print(`✓ This team project now measures with ${variant}.`);
+                }
+                catch (e) {
+                    deps.print(`  ! The measurement is written, but ${TEAM_FILE} could not be updated, so this team project still has no check variant. `
+                        + `Ask the lead to try again: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            if (res.stoppedBy === 'connection') {
+                lostConnection = true;
+                break;
+            }
+        }
+    }
+    finally {
+        off();
+    }
+    if (foreign) {
+        deps.print(`  ! Made with ${variant}, not the team project's ${(project.atcVariant ?? '').trim().toUpperCase()}. `
+            + 'The records are kept, but they are not counted in the picture.');
+    }
+    if (written)
+        refreshSheet(deps);
+    if (stop.signal.aborted || lostConnection) {
+        deps.print(`✗ ${lostConnection ? 'Lost the connection to SAP' : 'Stopped'} after ${measuredPackages} of ${todo.length} packages. What was measured is written. `
+            + 'Run the same command again to measure the rest.');
+        return 3;
+    }
+    deps.print(`✓ ${plural(written, 'package', 'packages')} measured, one record each.`);
+    deps.print('  Next: cspeach team status');
+    return written ? 0 : 1;
+}
 // ── outbox / rule ───────────────────────────────────────────────────────────
 function outbox(_args, deps) {
     const joined = joinedOrThrow();
@@ -1147,15 +1503,25 @@ function outbox(_args, deps) {
     deps.print('Each file is plain JSON: object names, decisions, statuses. No source code. Open one in Notepad to check.');
     return 0;
 }
+const RETIRE_RULING_NEEDS_REASON = 'A retire is confirmed with a reason: --reason "no callers (index read OK); usage unknown on this system; owner confirms"';
 function rule(args, deps) {
     const { positional, opts } = flags(args);
     const [type, name, classification] = positional;
     if (!type || !name || !CLASSIFICATIONS.includes(classification)) {
-        throw new RegisterError(`Usage: cspeach team rule <TYPE> <NAME> ${CLASSIFICATIONS.join('|')} [--reason "<why>"]`);
-    }
+        throw new RegisterError(`Usage: cspeach team rule <TYPE> <NAME> ${CLASSIFICATIONS.join('|')} [--reason "<why>"]   (a retire needs the reason)`);
+    }
+    // Read the way `decide` reads one: trimmed, a bare flag refused, at most 300.
+    if (opts.reason === 'true')
+        throw new RegisterError('--reason needs words, for example: --reason "reads BSID directly"');
+    const reason = (opts.reason ?? '').trim();
+    if (reason.length > MAX_REASON)
+        throw new RegisterError(`Keep the reason under ${MAX_REASON} characters.`);
+    // The lead's retire is what makes an object retired (D2), so it carries what was checked.
+    if (classification === 'retire' && !reason)
+        throw new RegisterError(RETIRE_RULING_NEEDS_REASON);
     const joined = joinedOrThrow();
     requireLead(readProjectFile(joined.projectDir), deps);
-    const res = writeRecord(joined, 'ruling', [{ key: objectKey(type, name), classification, ...(opts.reason ? { reason: opts.reason } : {}) }], { name: whoAmI(deps) }, {
+    const res = writeRecord(joined, 'ruling', [{ key: objectKey(type, name), classification, ...(reason ? { reason } : {}) }], { name: whoAmI(deps) }, {
         dir: path.join(joined.projectDir, 'rulings'), now: deps.now?.(),
         ...(deps.rand ? { rand: deps.rand } : {}),
     });
@@ -1164,3 +1530,243 @@ function rule(args, deps) {
     deps.print(`✓ Ruled ${objectKey(type, name)} = ${classification}.`);
     return 0;
 }
+// ── decide ──────────────────────────────────────────────────────────────────
+const DECIDE_USAGE = 'Usage: cspeach team decide <TYPE> <NAME> keep|fix|retire|rebuild|exception [--level A-D] [--target A-D] [--reason "<why>"]';
+const DECIDE_OPTIONS = ['level', 'target', 'reason'];
+/** The five words a person types, onto the four classifications the files hold (spec §4.2). */
+const DECIDE_WORDS = {
+    keep: { classification: 'keep' },
+    exception: { classification: 'keep', exception: true },
+    fix: { classification: 'fix' },
+    rebuild: { classification: 'redesign' },
+    redesign: { classification: 'redesign' },
+    retire: { classification: 'retire' },
+};
+const MAX_REASON = 300;
+export function parseDecideArgs(args) {
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts)) {
+        if (!DECIDE_OPTIONS.includes(name))
+            return { ok: false, message: `--${name} is not an option of team decide.\n${DECIDE_USAGE}` };
+    }
+    const [type, name, word] = positional;
+    const said = word ? DECIDE_WORDS[word.toLowerCase()] : undefined;
+    if (!type || !name || !said || positional.length > 3)
+        return { ok: false, message: DECIDE_USAGE };
+    const letter = (flag) => {
+        if (opts[flag] === undefined)
+            return { ok: true };
+        const value = levelOf(opts[flag].trim().toUpperCase());
+        return value ? { ok: true, value } : { ok: false };
+    };
+    const level = letter('level');
+    const target = letter('target');
+    if (!level.ok || !target.ok)
+        return { ok: false, message: 'A level is one of A, B, C or D. A uses only released APIs; D modifies SAP standard.' };
+    const moves = said.classification === 'fix' || said.classification === 'redesign';
+    if (target.value && !moves)
+        return { ok: false, message: 'A target level only goes with fix or rebuild.' };
+    if (opts.reason === 'true')
+        return { ok: false, message: '--reason needs words, for example: --reason "reads BSID directly"' };
+    const reason = (opts.reason ?? '').trim();
+    if (reason.length > MAX_REASON)
+        return { ok: false, message: `Keep the reason under ${MAX_REASON} characters.` };
+    if (said.exception && !reason)
+        return { ok: false, message: 'An accepted exception needs a reason: --reason "<why it stays>"' };
+    if (said.classification === 'retire' && !reason) {
+        return { ok: false, message: 'A retire needs a reason: say what was checked, for example: --reason "no callers (index read OK); usage unknown on this system"' };
+    }
+    return {
+        ok: true,
+        value: {
+            type: type.toUpperCase(), name: name.toUpperCase(),
+            row: {
+                classification: said.classification,
+                ...(said.exception ? { exception: true } : {}),
+                ...(level.value ? { level: level.value } : {}),
+                // Spec §4.2: a fix or a rebuild reaches A unless the person says otherwise.
+                ...(moves ? { targetLevel: target.value ?? 'A' } : {}),
+                ...(reason ? { reason } : {}),
+            },
+        },
+    };
+}
+const DECISION_WORDS = { keep: 'keep', fix: 'fix', redesign: 'rebuild beside the core', retire: 'retire' };
+function decisionWords(row) {
+    const parts = [row.exception ? 'accepted exception' : DECISION_WORDS[row.classification]];
+    if (row.level)
+        parts.push(`level ${row.level}`);
+    if (row.targetLevel)
+        parts.push(`target ${row.targetLevel}`);
+    return `${parts.join(', ')}${row.reason ? `, because: ${row.reason}` : ''}`;
+}
+function decide(args, deps) {
+    const parsed = parseDecideArgs(args);
+    if (!parsed.ok)
+        throw new RegisterError(parsed.message);
+    const joined = joinedOrThrow();
+    const { type, name, row } = parsed.value;
+    const res = writeRecord(joined, 'decision', [{ key: objectKey(type, name), ...row }], { name: whoAmI(deps) }, {
+        ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
+    });
+    if (!res.file)
+        throw new RegisterError(`${type} ${name} is not in this team project's object list.`);
+    deps.print(`✓ Recorded: ${type} ${name} — ${decisionWords(row)}.`);
+    if (row.classification === 'retire')
+        deps.print('Recorded as a retire candidate. It becomes retired when the lead confirms it.');
+    refreshSheet(deps);
+    return 0;
+}
+// ── fixed ───────────────────────────────────────────────────────────────────
+const FIXED_USAGE = 'Usage: cspeach team fixed <TYPE> <NAME> [--rule <id>] [--transport <request>]';
+const utcLine = (iso) => `${iso.slice(0, 16).replace('T', ' ')} UTC`;
+/**
+ * "I fixed this" — a claim, matched to a finding by (object, rule). It moves no
+ * colour to proven: only the next measurement does (spec §4.3).
+ */
+async function fixed(args, deps) {
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts)) {
+        if (name !== 'rule' && name !== 'transport')
+            throw new RegisterError(`--${name} is not an option of team fixed.\n${FIXED_USAGE}`);
+    }
+    const [rawType, rawName] = positional;
+    if (!rawType || !rawName || positional.length > 2)
+        throw new RegisterError(FIXED_USAGE);
+    const type = rawType.toUpperCase();
+    const name = rawName.toUpperCase();
+    const joined = joinedOrThrow();
+    const key = objectKey(type, name);
+    if (!readBaseline(joined.projectDir).some((o) => objectKey(o.type, o.name) === key)) {
+        // `shown()`: the person's own arguments, still printed through CSPeach.
+        throw new RegisterError(`${shown(type)} ${shown(name)} is not in this team project's object list.`);
+    }
+    let transport;
+    if (opts.transport !== undefined) {
+        transport = opts.transport === 'true' ? '' : opts.transport.trim().toUpperCase();
+        if (!/^[A-Z0-9]{1,20}$/.test(transport))
+            throw new RegisterError('--transport needs the request number, for example: --transport S4HK903500');
+    }
+    let rules;
+    if (opts.rule !== undefined) {
+        const rule = opts.rule === 'true' ? '' : normalizeRuleId(opts.rule);
+        if (!rule)
+            throw new RegisterError('--rule needs the rule id, for example: --rule "API:BSID"');
+        rules = [rule];
+    }
+    else {
+        const f = findingsByObject(joined.projectDir, joined.outboxDir).get(key);
+        if (!f?.latestAt)
+            throw new RegisterError('Nothing measured yet to claim against; name the rule with --rule.');
+        if (!f.latest.length) {
+            deps.print(`Nothing is open for ${type} ${name} at its last measurement (${utcLine(f.latestAt)}). Nothing was recorded.`);
+            return 0;
+        }
+        deps.print(`Open for ${type} ${name} at its last measurement, ${utcLine(f.latestAt)}:`);
+        for (const r of f.latest.slice(0, 10))
+            deps.print(`  ${r.count}× ${r.rule}${r.message ? ` — ${r.message}` : ''}`);
+        if (f.latest.length > 10)
+            deps.print(`  and ${f.latest.length - 10} more`);
+        if (!deps.ask)
+            throw new RegisterError('Marking findings fixed needs a yes. In a script, name each rule with --rule.');
+        const total = f.latest.reduce((n, r) => n + r.count, 0);
+        const answer = (await deps.ask(`Mark these ${plural(total, 'finding', 'findings')} as fixed? [y/n]`)).trim().toLowerCase();
+        if (answer !== 'y' && answer !== 'yes') {
+            deps.print('Nothing was recorded.');
+            return 1;
+        }
+        rules = f.latest.map((r) => r.rule);
+    }
+    writeRecord(joined, 'fix', rules.map((rule) => ({ key, rule, status: 'fixed', ...(transport ? { transport } : {}) })), { name: whoAmI(deps) }, { ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}) });
+    deps.print(`✓ Claimed: ${type} ${name}, ${plural(rules.length, 'rule', 'rules')} marked fixed. A claim is not proof — the next cspeach team refresh checks it.`);
+    refreshSheet(deps);
+    return 0;
+}
+// ── sheet ───────────────────────────────────────────────────────────────────
+function sheet(deps) {
+    const joined = joinedOrThrow();
+    const res = regenerateWorkingList(joined, whoAmI(deps), deps.now?.());
+    if (!res.ownsLane) {
+        deps.print('You own no lane in this team project, so there is no working list to write. The lead adds lanes with: cspeach team lane add');
+        return 0;
+    }
+    if (res.line)
+        deps.print(res.line.trimStart());
+    return res.file ? 0 : 1;
+}
+// ── report ──────────────────────────────────────────────────────────────────
+export const heldReportLine = (name) => `  ! "${name}" is open in another program, so it was not updated. Close it and run: cspeach team report`;
+/**
+ * The combined workbook and the status file, made from the team project folder
+ * (the same files the team page reads) and written whole, then renamed, into
+ * `outDir`. Used by `report` and by `plan import`, which makes them again so the
+ * lead sees the new export stamp.
+ *
+ * A report open in Excel is the likeliest failure here: Windows refuses the
+ * rename. Each file is tried on its own, so one held file never costs the
+ * other, and the caller is told by file name which one was not updated.
+ * writeWhole has already removed its .tmp when it throws.
+ */
+export function writeReports(projectDir, project, outDir, deps) {
+    const picture = registerFor(projectDir);
+    const asOf = (deps.now?.() ?? new Date()).toISOString();
+    const folderName = path.basename(projectDir);
+    const names = reportFileNames(project.name);
+    // The discovery file as the folder holds it: the status file says "could not be read"
+    // for one register-core cannot read, the way the page does.
+    const discovery = readEstate(projectDir);
+    const held = [];
+    const attempt = (name, write) => {
+        try {
+            write();
+            return true;
+        }
+        catch (e) {
+            if (!HELD.has(e?.code ?? ''))
+                throw e;
+            held.push(name);
+            return false;
+        }
+    };
+    const saved = [
+        attempt(names.xlsx, () => writeXlsxFile(path.join(outDir, names.xlsx), combinedSheets(picture.register, asOf, folderName))) ? names.xlsx : null,
+        attempt(names.html, () => writeWhole(path.join(outDir, names.html), statusHtmlFor({
+            project, register: picture.register, files: picture.files, unreadable: picture.unreadable,
+            checksum: project.baseline?.sha256 ? 'ok' : 'not-checked', asOf, folderName,
+            ...(discovery ? { estate: discovery.estate } : {}),
+        }))) ? names.html : null,
+    ].filter((n) => n !== null);
+    return { saved, held };
+}
+const REPORT_USAGE = 'Usage: cspeach team report [--out <folder>]';
+/**
+ * Lead only (spec §4.5). Reads the team project folder — the same files the team
+ * page reads, so its numbers are the page's — and writes two files whole, then
+ * renamed, into `reports/` or the folder named with --out. Never `writers/`.
+ */
+function report(args, deps) {
+    const { positional, opts } = flags(args);
+    if (positional.length || Object.keys(opts).some((k) => k !== 'out') || opts.out === 'true')
+        throw new RegisterError(REPORT_USAGE);
+    const joined = joinedOrThrow();
+    const project = readProjectFile(joined.projectDir);
+    requireLead(project, deps);
+    const outDir = opts.out ? path.resolve(opts.out) : path.join(joined.projectDir, 'reports');
+    const { saved, held } = writeReports(joined.projectDir, project, outDir, deps);
+    const where = opts.out ? 'the folder you named' : 'the reports folder of the team project';
+    if (saved.length)
+        deps.print(`✓ Saved ${saved.map((n) => `"${n}"`).join(' and ')} in ${where}.`);
+    for (const name of held)
+        deps.print(heldReportLine(name));
+    // Records on this laptop that have not reached the folder are not in the report.
+    const ownDir = path.join(joined.outboxDir, 'writers', joined.writerId, 'records');
+    const inFolder = path.join(joined.projectDir, 'writers', joined.writerId, 'records');
+    if (path.resolve(ownDir) !== path.resolve(inFolder) && fs.existsSync(ownDir)) {
+        const missing = fs.readdirSync(ownDir).filter((f) => f.endsWith('.json') && !fs.existsSync(path.join(inFolder, f))).length;
+        if (missing) {
+            deps.print(`  ${plural(missing, 'record file on this laptop is', 'record files on this laptop are')} not in the team project folder yet, `
+                + `so ${missing === 1 ? 'it is' : 'they are'} not in this report.`);
+        }
+    }
+    return held.length ? 1 : 0;
+}