@cspeach/cli 1.1.30 → 1.1.31

package/dist/commands/team.js

@@ -18,18 +18,20 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { activeOf, levelOf, normalizeRuleId, 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, defaultOutboxDir, loadState, projectIdFor, readBaseline, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.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'];
 /**
@@ -43,7 +45,7 @@ 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();
@@ -74,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++) {
@@ -97,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. */
@@ -110,8 +112,9 @@ 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);
@@ -121,8 +124,12 @@ export async function runTeamCommand(args, 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|decide|fixed|sheet|report   (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;
         }
     }
@@ -131,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>');
@@ -148,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'];
 /**
@@ -178,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
@@ -210,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);
@@ -225,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)
@@ -244,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.
@@ -272,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']);
 /**
@@ -376,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>');
@@ -394,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);
@@ -410,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.');
@@ -435,6 +584,8 @@ 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 ──────────────────────────────────────────────────────────────────
@@ -453,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
@@ -466,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])
@@ -478,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)
@@ -491,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>`);
@@ -546,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. */
@@ -558,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'];
@@ -648,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');
@@ -691,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();
@@ -930,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();
@@ -1070,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);
@@ -1107,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, () => {
@@ -1182,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();
@@ -1200,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 } : {}),
     });
@@ -1260,6 +1573,9 @@ export function parseDecideArgs(args) {
         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: {
@@ -1296,6 +1612,8 @@ function decide(args, deps) {
     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;
 }
@@ -1377,28 +1695,26 @@ function sheet(deps) {
     return res.file ? 0 : 1;
 }
 // ── report ──────────────────────────────────────────────────────────────────
-const REPORT_USAGE = 'Usage: cspeach team report [--out <folder>]';
+export const heldReportLine = (name) => `  ! "${name}" is open in another program, so it was not updated. Close it and run: cspeach team report`;
 /**
- * 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/`.
+ * 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.
  */
-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 picture = registerFor(joined.projectDir);
+export function writeReports(projectDir, project, outDir, deps) {
+    const picture = registerFor(projectDir);
     const asOf = (deps.now?.() ?? new Date()).toISOString();
-    const folderName = path.basename(joined.projectDir);
-    const outDir = opts.out ? path.resolve(opts.out) : path.join(joined.projectDir, 'reports');
+    const folderName = path.basename(projectDir);
     const names = reportFileNames(project.name);
-    // 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 lead is told by file name which one was not updated.
-    // writeWhole has already removed its .tmp when it throws.
+    // 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 {
@@ -1417,13 +1733,31 @@ function report(args, deps) {
         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(`  ! "${name}" is open in another program, so it was not updated. Close it and run: cspeach team report`);
+        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');