@cspeach/cli 1.1.30 → 1.1.32

package/dist/commands/team.js

@@ -9,6 +9,7 @@
  *   status [folder] anyone: the register as text
  *   outbox          what this laptop has recorded, and where
  *   rule …          lead: settle a disagreement
+ *   rules …         the decision rules: anyone views, the lead changes (team-rules.ts)
  *   leave           stop recording
  *
  * Every path written here is one a person typed. Nothing is written to a
@@ -18,18 +19,24 @@
 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 { isAppLabel, isPatternWord, laneIdFor, levelOf, normalizeRuleId, objectKey, proposeLanes, scopeFromWords, targetsOf, } 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 { 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 { 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_API_DOCUMENTS, MAX_SECOND_PASS, measure, noVariantYetMessage, scopeLabel, scopeObjects, variantMismatchMessage, } from '../register/measure.js';
+import { measureFromFile, shown, shownUpTo, upToFive } from '../register/atc-file.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 { EXPORTS_DIR, exportsOn, setExports, writeExportFiles } from '../register/export-files.js';
+import { previousAsOfIn, reportViewFor, statusHtmlFor } from '../register/status-html.js';
+import { firstBlockLines, awaitingWord, lastCheckWord } from '../register/status-file/report-model.js';
+import { lookupVariant, variantLookupLine } from '../register/variant.js';
+import { teamDiscover, evidenceRows, EVIDENCE_LINE, OUTSIDE_LINE } from './team-discover.js';
+import { rulesCommand } from './team-rules.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 +50,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 +81,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 +104,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,19 +117,28 @@ 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 'rules': return rulesCommand(rest, deps);
             case 'leave': return leave(deps);
             case 'decide': return decide(rest, deps);
+            case 'target': return target(rest, deps);
             case 'fixed': return await fixed(rest, deps);
             case 'sheet': return sheet(deps);
             case 'report': return report(rest, deps);
+            case 'export': return exportVerb(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);
+            case 'rebuild': return await rebuildVerb(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|target|fixed|sheet|report|export|discover|focus|priority|plan|start|rebuild|rules   (cspeach --help for details)');
                 return sub ? 1 : 0;
         }
     }
@@ -131,16 +147,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 +170,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 +200,181 @@ function unknownInitOption(name) {
         return said;
     return `${said} Did you mean --${guess}?`;
 }
+const START_USAGE = 'Usage: cspeach team start <packages> | --for "<area words, e.g. FI and SD>" [--developers "<names>, me"] '
+    + '[--name "<name>"] [--atc-variant <NAME>] [--folder <folder>] [--no-measure] [--sap-alias <name>]';
+const START_OPTIONS = ['name', 'atc-variant', 'folder', 'no-measure', 'sap-alias', 'for', 'developers'];
+/** The check a project measures with when nobody names one. */
+export const DEFAULT_ATC_VARIANT = 'ABAP_CLOUD_READINESS';
+/** I16: `--for` reads the packages from the folder's discovery; without one there is nothing to read them from. */
+export const NO_DISCOVERY_LINE = 'Nothing is known about the system yet. Run: cspeach team discover, then try again.';
+/** Step 2 (owner: "we need to give some regex. This is not good."): nobody types a pattern. */
+const NOT_A_PATTERN = 'Name each package in full, for example ZFI_AR — not a pattern.';
+const FOR_NOT_A_PATTERN = 'Say the area or the packages by name, for example --for "FI and SD" — not a pattern.';
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
+/** Longest name a person gives with --as or --developers (F13: like a lead name). */
+export const MAX_PERSON_NAME = 60;
+const sameName = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+const firstWordOf = (name) => (name.trim().split(/\s+/)[0] ?? '').toLowerCase();
+/**
+ * A person's name typed on the command line (`team join --as`, `--developers`,
+ * `lane move --to`): plain text, no control characters, at most 60 characters.
+ * `what` starts the message, so the line says which option was wrong.
+ */
+export function personName(raw, what, example = 'James Miller') {
+    const name = raw === undefined || raw === 'true' ? '' : raw.trim();
+    if (!name)
+        throw new RegisterError(`${what} needs a name, for example: ${what} "${example}"`);
+    if (CONTROL.test(name) || name.length > MAX_PERSON_NAME) {
+        throw new RegisterError(`${what} must be a plain name of at most ${MAX_PERSON_NAME} characters, without control characters.`);
+    }
+    return name;
+}
+/** `--developers "James Miller, Mike Chen, me"`: the names as given, checked, each once. `me` stays `me` here. */
+function developersOf(raw) {
+    if (raw === undefined)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const d of list(raw === 'true' ? '' : raw)) {
+        if (isPatternWord(d))
+            throw new RegisterError('Name each developer in full, for example "James Miller" — not a pattern.');
+        const name = personName(d, '--developers');
+        if (seen.has(name.toLowerCase()))
+            continue;
+        seen.add(name.toLowerCase());
+        out.push(name);
+    }
+    if (!out.length)
+        throw new RegisterError('--developers needs at least one name, for example: --developers "James Miller, me"');
+    return out;
+}
+/**
+ * 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.
+ *
+ * Step 2 (spec §3.6, I16) — set up by name: `--for "FI and SD"` reads the
+ * packages from the folder's discovery (`scopeFromWords`, names only), and
+ * `--developers "James Miller, Mike Chen, me"` proposes one lane each,
+ * balanced by work (`proposeLanes`), written as package NAMES. Nothing is
+ * measured on that path (`--no-measure`): the lanes are balanced by objects
+ * and the table says so. A typed pattern is refused in one line.
+ */
+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 typed = positional.join(',').split(',').map((p) => p.trim().toUpperCase()).filter(Boolean);
+    if (typed.some(isPatternWord))
+        throw new RegisterError(NOT_A_PATTERN);
+    if (opts.for === 'true')
+        throw new RegisterError(START_USAGE);
+    const forWords = (opts.for ?? '').trim();
+    if (forWords && forWords.split(/[\s,;&]+/).some(isPatternWord))
+        throw new RegisterError(FOR_NOT_A_PATTERN);
+    if (forWords && typed.length)
+        throw new RegisterError(`Name the packages or say --for, not both.\n${START_USAGE}`);
+    const developers = developersOf(opts.developers);
+    if (!forWords && !typed.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.');
+    let packages = [...new Set(typed)];
+    let unmatched = [];
+    if (forWords) {
+        const found = readEstate(dir);
+        if (!found) {
+            deps.print(NO_DISCOVERY_LINE);
+            return 1;
+        }
+        const scope = scopeFromWords(found.estate, forWords);
+        unmatched = scope.unmatched.map((w) => shown(w));
+        if (!scope.packages.length) {
+            throw new RegisterError(`Nothing in the inventory matched: ${unmatched.join(', ') || shown(forWords)}. Name an area such as FI, or a package in full.`);
+        }
+        packages = scope.packages;
+    }
+    const lead = deps.identity().name;
+    const name = opts.name && opts.name !== 'true' ? opts.name : forWords ? shownUpTo(forWords, 80) : packages.join(', ');
+    const variant = opts['atc-variant'] && opts['atc-variant'] !== 'true' ? opts['atc-variant'] : DEFAULT_ATC_VARIANT;
+    // I16: a setup by name measures nothing yet; the first check is the lead's next step.
+    const noMeasure = !!opts['no-measure'] || !!forWords || developers.length > 0;
+    // 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,
+        ...(noMeasure ? ['--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);
+    let lanesWritten = null;
+    let note = '';
+    let laneId = (lead.trim().split(/\s+/)[0] ?? '').toLowerCase().replace(/[^a-z0-9]/g, '') || 'me';
+    if (developers.length) {
+        // `me` is the seat, named only now: after the join, it is the name this folder records under.
+        const me = whoAmI(deps);
+        const owners = [];
+        for (const d of developers.map((x) => (x.toLowerCase() === 'me' ? me : x)))
+            if (!owners.some((o) => sameName(o, d)))
+                owners.push(d);
+        const project = readProjectFile(dir);
+        const proposal = proposeLanes(registerFor(dir).register, owners);
+        note = proposal.note ?? 'balanced by the work: objects with findings count three times, then findings, then objects';
+        lanesWritten = proposal.lanes.map((l) => ({ id: l.id, owner: l.owner, packages: l.packages, objects: l.objects }));
+        writeLanes(dir, project.projectId, lanesWritten.filter((l) => l.packages.length).map((l) => ({ id: l.id, owner: l.owner, packages: l.packages, namePatterns: [] })));
+        laneId = lanesWritten.find((l) => sameName(l.owner, me) && l.packages.length)?.id ?? '';
+    }
+    else {
+        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}.`);
+    if (forWords)
+        deps.print(`  Packages: ${packages.join(', ')}.`);
+    if (unmatched.length)
+        deps.print(`  Nothing in the inventory matched: ${unmatched.join(', ')}.`);
+    // §3.1: what the variant lookup found, said on every path (init's own line, kept back above).
+    for (const l of said.filter((x) => /^ {2}(! )?CSPeach could not (find|confirm) the variant /.test(x)))
+        deps.print(l);
+    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.`);
+    // I15: above 500 objects the first check is per package, also when this start measured nothing on purpose.
+    else if (said.includes(FIRST_CHECK_PER_PACKAGE_LINE) || objects > FIRST_CHECK_WHOLE_MAX)
+        deps.print(FIRST_CHECK_PER_PACKAGE_LINE);
+    else if (lanesWritten)
+        deps.print('  No check run yet: cspeach team refresh --all measures it.');
+    else if (noMeasure)
+        deps.print('  No check run yet: cspeach team refresh measures it.');
+    if (lanesWritten) {
+        deps.print(`  Lanes, ${note}.`);
+        for (const l of lanesWritten) {
+            deps.print(l.packages.length
+                ? `  ${l.owner} (${l.id}): ${l.packages.join(', ')} · ${plural(l.objects, 'object', 'objects')}`
+                : `  ${l.owner}: no package yet.`);
+        }
+        deps.print('  Move a package: cspeach team lane move --packages <names> --to <name>');
+        deps.print('  Your results go straight into this folder.');
+    }
+    else {
+        deps.print(`  You own all ${plural(objects, 'object', 'objects')}. Your results go straight into this folder.`);
+    }
+    if (laneId)
+        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,7 +407,24 @@ 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']);
+    // D5 / I8: the named variant, looked up on the system before it is saved.
+    // A global variant found needs no words; anything else is said, and the
+    // confirmed name is still saved (the first check says if SAP refuses it).
+    if (atcVariant) {
+        const look = await lookupVariant(sql, atcVariant);
+        if (look === 'unreadable' || !look.found || look.privateTo) {
+            const sid = shown(system?.sid ?? 'the system');
+            deps.print(look !== 'unreadable' && !look.found
+                ? `  ! CSPeach could not find the variant ${atcVariant} on ${sid}. It is saved as named; the first check shows whether SAP knows it.`
+                : `  ${look === 'unreadable' ? '' : '! '}${variantLookupLine(atcVariant, sid, look)}`);
+        }
+    }
     deps.print('Reading the package list from SAP…');
     const all = await listCustomPackages(sql);
     const patterns = list(opts.packages);
@@ -225,6 +439,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)
@@ -241,12 +458,17 @@ async function init(args, deps) {
         createdAt: now.toISOString(),
     };
     fs.mkdirSync(path.join(dir, 'baseline'), { recursive: true });
-    fs.writeFileSync(path.join(dir, BASELINE_FILE), baselineText);
-    fs.writeFileSync(path.join(dir, TEAM_FILE), `${JSON.stringify(project, null, 2)}\n`);
+    writeWhole(path.join(dir, BASELINE_FILE), baselineText);
+    writeWhole(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.
@@ -267,11 +489,75 @@ async function init(args, deps) {
             deps.print(l);
         return joinedRc;
     }
-    await firstMeasurement(dir, project, pull.objects, opts, atc, deps);
+    // Step 2 (I15): above 500 objects one run over the whole baseline would be cut
+    // by its 30-minute budget. No cut first check: the per-package one is named instead.
+    if (pull.objects.length > FIRST_CHECK_WHOLE_MAX && !opts['no-measure'])
+        deps.print(FIRST_CHECK_PER_PACKAGE_LINE);
+    else
+        await firstMeasurement(dir, project, pull.objects, opts, atc, deps, sql);
     for (const l of joinLines)
         deps.print(l);
     return 0;
 }
+/** Above this many objects, `init` does not run the first check over the whole baseline (I15). */
+export const FIRST_CHECK_WHOLE_MAX = 500;
+export const FIRST_CHECK_PER_PACKAGE_LINE = '  First check per package: cspeach team refresh --all --per-package (it resumes if stopped).';
+/**
+ * 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']);
 /**
@@ -285,7 +571,7 @@ const CANNOT_WRITE = new Set(['EPERM', 'EACCES', 'EROFS', 'ENOSPC', 'EISDIR', 'E
  * an estate the run reports nothing back for at all — no object listed — leaves
  * nothing to write, and then that is said out loud and `init` still succeeds.
  */
-async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
+async function firstMeasurement(dir, project, baseline, opts, atc, deps, sql) {
     const LATER = 'Measure when you can: cspeach team refresh --all';
     if (opts['no-measure']) {
         deps.print('  Not measured (--no-measure). When you are ready: cspeach team refresh --all');
@@ -318,6 +604,7 @@ async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
             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,
+            ...(sql ? { sql } : {}),
             ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
             signal: stop.signal,
             onProgress: progressLine(deps),
@@ -361,11 +648,15 @@ async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
 function join(args, deps, asName) {
     const { positional, opts } = flags(args);
     if (!positional[0])
-        throw new RegisterError('Usage: cspeach team join <team project folder> [--outbox <folder>]');
+        throw new RegisterError('Usage: cspeach team join <team project folder> [--outbox <folder>] [--as "<your name>"]');
+    // F13: `--as "James Miller"` joins under the lane owner's name, kept in
+    // JoinedProject.name, so the writer id and every record are that person.
     const projectDir = path.resolve(positional[0]);
     const project = readProjectFile(projectDir);
     const objects = readBaseline(projectDir).length; // also verifies the checksum
     const state = loadState();
+    if (opts.as !== undefined && asName === undefined)
+        asName = joinAsName(opts.as, projectDir, project, state.projects[project.projectId]?.name, deps);
     const outboxDir = path.resolve(opts.outbox ?? state.projects[project.projectId]?.outboxDir ?? defaultOutboxDir(project.projectId));
     // A name given once is kept: joining again must not turn the lead back into
     // whatever the machine calls them.
@@ -376,11 +667,96 @@ function join(args, deps, asName) {
     state.active = project.projectId;
     saveState(state);
     deps.print(`✓ Joined "${project.name}" (${objects} objects, lead ${project.lead.name}) as ${writerId}.`);
-    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>');
+    // 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.');
+    }
+    else {
+        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>');
+    }
+    const owns = ownsNothingLine(projectDir, project, saved ?? deps.identity().name);
+    if (owns)
+        deps.print(`  ${owns}`);
     return 0;
 }
+/**
+ * A developer's first day (spec §3.6, F13, cut 5): someone who owns no lane in
+ * a folder that has lanes is told so — never left on "Done" with nothing to
+ * do. When one lane owner shares their first name, the line says how to join
+ * under that name; two such owners are never guessed between. The lead, and a
+ * folder with no lanes yet, get nothing. Null when there is nothing to say.
+ */
+export function ownsNothingLine(projectDir, project, me) {
+    const lanes = readLanes(projectDir);
+    if (!lanes.length || sameName(me, project.lead.name))
+        return null;
+    const m = ownerMatch(lanes, me);
+    if (m.kind === 'exact')
+        return null;
+    if (m.kind === 'one')
+        return `Are you ${m.owner}? Join with: cspeach team join . --as "${m.owner}"`;
+    if (m.kind === 'several')
+        return severalLine(m);
+    return `You own nothing here yet. Ask ${shown(project.lead.name)} to move packages to you.`;
+}
+/**
+ * The lane owner a seat may be (architecture §D, F13, cut 5) — the ONE place
+ * this is decided, for `team join` and the journey's JOIN card. Owners compare
+ * case-insensitively ("James Miller" and "james miller" are one person, the
+ * first spelling kept); the first word alone makes a candidate. Names come
+ * out of a synced file, so the owner returned is cleaned for the screen.
+ */
+export function ownerMatch(lanes, me) {
+    if (lanes.some((l) => sameName(l.owner, me)))
+        return { kind: 'exact' };
+    const first = firstWordOf(me);
+    const people = new Map();
+    for (const l of lanes) {
+        if (!first || firstWordOf(l.owner) !== first)
+            continue;
+        const key = l.owner.trim().toLowerCase();
+        const seen = people.get(key);
+        if (seen)
+            seen.laneIds.push(l.id);
+        else
+            people.set(key, { owner: shown(l.owner).trim(), laneIds: [l.id] });
+    }
+    const found = [...people.values()];
+    if (found.length > 1)
+        return { kind: 'several', called: found[0].owner.split(/\s+/)[0], count: found.length };
+    return found[0] ? { kind: 'one', ...found[0] } : { kind: 'none' };
+}
+/** Cut 5: never a guess between two people. */
+export const severalLine = (m) => `${m.count === 2 ? 'Two' : m.count} people here are called ${m.called}. Join with: cspeach team join . --as "<full name>"`;
+/**
+ * `--as` (F13; review finding 2): only the name of someone who owns a lane
+ * here, in that lane's spelling. The lead's name only from the lead's own
+ * seat — otherwise one option would hand any joiner the lead's powers.
+ */
+function joinAsName(raw, projectDir, project, savedName, deps) {
+    const name = personName(raw, '--as');
+    const lead = project.lead.name;
+    if (sameName(name, lead)) {
+        if (![savedName, deps.identity().name].some((n) => !!n && sameName(n, lead))) {
+            throw new RegisterError(`Only the lead's own seat joins as ${shown(lead)}.`);
+        }
+        return lead;
+    }
+    const lanes = readLanes(projectDir);
+    const owner = lanes.find((l) => sameName(l.owner, name));
+    if (!owner) {
+        const owners = [];
+        for (const l of lanes)
+            if (!owners.some((o) => sameName(o, l.owner)))
+                owners.push(shown(l.owner).trim());
+        throw new RegisterError(owners.length
+            ? `--as takes the name of someone who owns a lane here: ${owners.join(', ')}.`
+            : '--as takes the name of someone who owns a lane here; nobody does yet.');
+    }
+    return owner.owner.trim();
+}
 function leave(deps) {
     const state = loadState();
     if (!state.active) {
@@ -394,8 +770,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);
@@ -408,16 +786,24 @@ function lane(args, deps) {
         return 0;
     }
     requireLead(project, deps);
+    if (verb === 'move')
+        return laneMove(positional, opts, joined, project, lanes, 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, move, 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,14 +821,79 @@ 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;
+}
+const MOVE_USAGE = 'Usage: cspeach team lane move --packages <names> --to <developer> [--reason "<why>"]';
+/** The first pattern a lane holds (a package with `*`, or any name pattern); undefined for a lane of names. */
+const patternOf = (l) => l.packages.find((p) => p.includes('*')) ?? l.namePatterns[0];
+/**
+ * `team lane move --packages ZSD_ORDERS --to mike` (spec §3.6, F14): package
+ * NAMES move from whichever lane holds them to the developer's lane — a new
+ * lane of names when that developer has none yet. Lanes of names only: a lane
+ * that holds a pattern cannot give up one package, so the move is refused in
+ * one line and nothing is written. A lane left empty is removed.
+ */
+function laneMove(positional, opts, joined, project, lanes, deps) {
+    const names = [...new Set(list(opts.packages === 'true' ? '' : opts.packages).map((p) => p.toUpperCase()))];
+    if (positional.length || !names.length || !opts.to || opts.to === 'true')
+        throw new RegisterError(MOVE_USAGE);
+    if (names.some(isPatternWord))
+        throw new RegisterError('Name each package in full, for example ZSD_ORDERS — not a pattern.');
+    const known = new Set(readBaseline(joined.projectDir).map((o) => o.package.toUpperCase()));
+    for (const n of names)
+        if (!known.has(n))
+            throw new RegisterError(`${shown(n)} is not a package of this team project.`);
+    const to = personName(opts.to, '--to');
+    const target = lanes.find((l) => l.id.toLowerCase() === to.toLowerCase()) ?? lanes.find((l) => sameName(l.owner, to));
+    const holders = lanes.filter((l) => l !== target && l.packages.some((p) => names.some((n) => matches(p, n))));
+    for (const l of [...holders, ...(target ? [target] : [])]) {
+        const p = patternOf(l);
+        if (p) {
+            throw new RegisterError(`Lane ${l.id} uses the pattern ${p}; CSPeach cannot move one package out of a pattern. `
+                + `Rewrite the lane with names: cspeach team lane add ${l.id} --owner … --packages <names>.`);
+        }
+    }
+    // Review finding 7: a move that changes nothing says so and writes nothing.
+    if (target && !holders.length && names.every((n) => target.packages.some((p) => p.toUpperCase() === n))) {
+        deps.print(`Nothing to move: ${names.join(', ')} ${names.length === 1 ? 'is' : 'are'} already in ${shown(target.owner)}'s lane.`);
+        return 0;
+    }
+    const reason = reasonFrom(opts, false);
+    const into = target
+        ? { ...target, packages: [...target.packages, ...names.filter((n) => !target.packages.some((p) => p.toUpperCase() === n))] }
+        : { id: laneIdFor(to, new Set(lanes.map((l) => l.id))), owner: to, packages: names, namePatterns: [] };
+    const removed = [];
+    const next = [];
+    for (const l of lanes) {
+        if (l === target) {
+            next.push(into);
+            continue;
+        }
+        if (!holders.includes(l)) {
+            next.push(l);
+            continue;
+        }
+        const left = l.packages.filter((p) => !names.includes(p.toUpperCase()));
+        if (left.length || l.namePatterns.length)
+            next.push({ ...l, packages: left });
+        else
+            removed.push(l.id);
+    }
+    if (!target)
+        next.push(into);
+    writeLanes(joined.projectDir, project.projectId, next);
+    const mine = registerFor(joined.projectDir, joined.outboxDir).register.lanes.find((l) => l.id === into.id);
+    deps.print(`✓ ${names.join(', ')} moved to ${shown(into.owner)} (${into.id}): `
+        + `${plural(into.packages.length, 'package', 'packages')}, ${plural(mine?.objects ?? 0, 'object', 'objects')}.`);
+    for (const id of removed)
+        deps.print(`  Lane ${id} held nothing else and was removed.`);
+    if (reason)
+        deps.print(laneChangeRecord(deps, 'add', target, into, into.id, reason));
     return 0;
 }
 // ── status ──────────────────────────────────────────────────────────────────
-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'],
-    ['regressed', 'regressed'], ['retired', 'retired'],
-];
 function status(args, deps) {
     const { positional } = flags(args);
     const joined = activeProject();
@@ -453,36 +904,39 @@ 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})`);
-    // 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;
-    deps.print(`${t.objects} objects, ${t.active} active. ${t.decided} decided. `
-        + `${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
-    // read in — so "from a file" is said of the run the date belongs to.
-    const lastRun = [...r.runs].reverse().find((run) => run.at === r.lastMeasuredAt);
-    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.');
+    // Step 2 (the one report): the first screen is the status page's first
+    // block, from the same model — coverage first, then the numbers. The
+    // previous page in reports/ says where "changed since" starts.
+    const asOf = (deps.now?.() ?? new Date()).toISOString();
+    const previousAsOf = previousAsOfIn(path.join(projectDir, 'reports', reportFileNames(project.name).html));
+    const view = reportViewFor({ project, register: r, asOf, previousAsOf });
+    for (const l of firstBlockLines(view))
+        deps.print(l);
     deps.print('');
-    for (const [state, word] of STATE_WORDS)
-        if (t.byState[state])
-            deps.print(`  ${String(t.byState[state]).padStart(6)}  ${word}`);
+    deps.print(nowLine(r));
+    for (const l of targetLines(project))
+        deps.print(l);
+    // Spec §3.6: a joiner who owns nothing reads that first, never a finished picture.
+    if (!positional[0] && joined) {
+        const owns = ownsNothingLine(projectDir, project, whoAmI(deps));
+        if (owns)
+            deps.print(owns);
+    }
     deps.print('');
-    if (r.lanes.length) {
-        // The same columns, in the same order, as the team project page's lane table,
-        // counted with the same three functions. One lane must not read "50% done"
-        // in a browser and "3 done" here.
-        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)}  `
-                + `${l.lastRecordAt ? l.lastRecordAt.slice(0, 10) : 'nothing yet'}`);
+    if (view.lanes.length) {
+        // Every lane together, in the order the lanes were set up — never ranked.
+        deps.print(`${'Developer'.padEnd(20)} Objects Decided Fixes proven Awaiting check      Kept Rebuilds Fix failed  Last check`);
+        for (const row of view.lanes) {
+            deps.print(`${row.developer.padEnd(20)} ${String(row.objects).padStart(7)} ${String(row.decided).padStart(7)} `
+                + `${String(row.fixesProven).padStart(12)} ${awaitingWord(row).padEnd(18)} ${String(row.kept).padStart(4)} `
+                + `${String(row.rebuilds).padStart(8)} ${String(row.fixFailed).padStart(10)}  ${lastCheckWord(row)}`);
+        }
+        // What each lane does next, in the priority order every surface sorts by. No %.
+        for (const row of view.lanes) {
+            if (row.laneId === null)
+                continue;
+            deps.print(`  ${row.developer}: Next: ${row.next.length ? row.next.join(', ') : 'nothing open'}`);
         }
-        // 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)
             deps.print(`Lane ${id} now means: in these packages AND matching these names.`);
         deps.print('');
@@ -491,6 +945,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 +1004,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 +1017,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 +1107,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 +1155,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();
@@ -863,6 +1329,38 @@ function notMeasuredLines(res, deps, words = {}) {
             + someNames(res.unsupportedNames));
     }
 }
+/**
+ * What reading API names found and cost, said in the summary line: "Read n
+ * API names", and — when finding documents were read — how many and how long
+ * (each is one call to SAP). Findings left unnamed are counted with the reason:
+ * they carry no `uses`, so they stay open for B.
+ */
+export function apiNamesWords(a) {
+    if (!a || !a.findings)
+        return { suffix: '', warning: null };
+    const docs = a.documents
+        ? ` (${plural(a.documents, 'finding document', 'finding documents')} from SAP, ${(a.ms / 1000).toFixed(1)} s)`
+        : '';
+    const suffix = ` Read ${plural(a.named, 'API name', 'API names')}${docs}.`;
+    if (!a.unnamed)
+        return { suffix, warning: null };
+    const one = a.unnamed === 1;
+    // Review M3: every reason, in words. With one finding the count is left off.
+    const reasons = [
+        [a.namedNone, 'SAP named none'],
+        [a.unreadable, a.unreadable === 1 && one ? 'its document could not be read' : 'whose document could not be read'],
+        [a.overCap, `past the limit of ${MAX_API_DOCUMENTS} documents per run`],
+        [a.stopped, 'not read because the run was stopped'],
+        [a.notLookedUp, 'not looked up'],
+    ];
+    const why = reasons.filter(([n]) => n > 0).map(([n, w]) => (one ? w : `${n} ${w}`)).join(', ');
+    return {
+        suffix,
+        // "API-usage findings": the released-API check reports deprecated APIs too, not only unreleased ones.
+        warning: `  ! ${plural(a.unnamed, 'API-usage finding', 'API-usage findings')} ${one ? 'has' : 'have'} no API name, `
+            + `so ${one ? 'it stays' : 'they stay'} open for B${why ? `: ${why}` : ''}.`,
+    };
+}
 export function reportMeasurement(res, variant, deps, foreignTo, words = {}) {
     if (!res.file) {
         deps.print(words.nothing ?? '✗ Nothing was measured, so nothing was written.');
@@ -872,7 +1370,10 @@ export function reportMeasurement(res, variant, deps, foreignTo, words = {}) {
         notMeasuredLines(res, deps, words);
         return;
     }
-    deps.print(words.headline ?? `✓ ${plural(res.measured, 'object measured', 'objects measured')}, ${res.withFindings} with findings.`);
+    const api = apiNamesWords(res.apiNames);
+    deps.print((words.headline ?? `✓ ${plural(res.measured, 'object measured', 'objects measured')}, ${res.withFindings} with findings.`) + api.suffix);
+    if (api.warning)
+        deps.print(api.warning);
     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
@@ -930,7 +1431,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 +1571,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);
@@ -1094,8 +1605,9 @@ async function refresh(args, deps) {
     if (!inScope.length)
         throw new RegisterError(`Nothing in this team project matches ${scopeLabel(scope)}.`);
     let atc;
+    let sql;
     try {
-        ({ atc } = await deps.connect(opts.sapAlias));
+        ({ atc, sql } = await deps.connect(opts.sapAlias));
     }
     catch (e) {
         // One line, the reason, no stack: "no system configured", a dead VPN and a
@@ -1107,6 +1619,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, sql }, deps);
     deps.print(`Measuring ${scopeWords(scope)} with ${variant}: ${plural(inScope.length, 'object', 'objects')}.`);
     const stop = new AbortController();
     const off = onInterrupt(deps, () => {
@@ -1130,6 +1644,7 @@ async function refresh(args, deps) {
             ...(foreign || persist ? { forceVariant: true } : {}),
             signal: stop.signal,
             confirmAbsent: true,
+            sql,
             onProgress: progressLine(deps),
         });
     }
@@ -1182,6 +1697,124 @@ 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, sql } = 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.
+            // Step 2 (I15): nor is a second pass that left silent objects out or never reached some.
+            const pass = run.secondPass;
+            if (c && c.asked > 0 && c.failed === 0 && c.notRun === 0
+                && c.measured + (c.unsupported ?? 0) + (c.absent ?? 0) >= c.asked
+                && !(pass && pass.skipped > 0) && (pass?.notChecked ?? 0) === 0)
+                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,
+                ...(sql ? { sql } : {}),
+                onProgress: progressLine(deps),
+            });
+            measuredPackages += 1;
+            if (res.file) {
+                written += 1;
+                const api = apiNamesWords(res.apiNames);
+                deps.print(`  ✓ ${pkg}: ${plural(res.measured, 'object measured', 'objects measured')}, ${res.withFindings} with findings.${api.suffix} Written: ${path.basename(res.file)}`);
+                if (api.warning)
+                    deps.print(api.warning);
+            }
+            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 +1833,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 } : {}),
     });
@@ -1218,8 +1861,11 @@ function rule(args, deps) {
     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'];
+const DECIDE_USAGE = 'Usage: cspeach team decide <TYPE> <NAME> keep|fix|retire|rebuild|exception [--level A-D] [--target A-D] [--reason "<why>"] [--kind app|class|api] [--app <APP>]';
+const DECIDE_OPTIONS = ['level', 'target', 'reason', 'kind', 'app'];
+/** Step 2 (D3): what a rebuild becomes, said with `--kind` beside `rebuild` only. */
+const REBUILD_KINDS = ['app', 'class', 'api'];
+const REBUILD_KIND_WORDS = { app: 'as an app', class: 'as a clean class', api: 'as an API service' };
 /** The five words a person types, onto the four classifications the files hold (spec §4.2). */
 const DECIDE_WORDS = {
     keep: { classification: 'keep' },
@@ -1260,10 +1906,26 @@ 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"' };
+    }
+    const rebuild = said.classification === 'redesign';
+    if ((opts.kind !== undefined || opts.app !== undefined) && !rebuild)
+        return { ok: false, message: '--kind and --app only go with rebuild.' };
+    const kind = opts.kind === undefined ? undefined : opts.kind.trim().toLowerCase();
+    if (kind !== undefined && !REBUILD_KINDS.includes(kind))
+        return { ok: false, message: 'A rebuild kind is app, class or api.' };
+    const app = opts.app === undefined ? undefined : opts.app.trim().toUpperCase();
+    if (app !== undefined && !isAppLabel(app))
+        return { ok: false, message: '--app is a name of letters, digits and underscores, for example AR_COCKPIT (not CON, NUL, AUX, PRN, COM1-9 or LPT1-9).' };
     return {
         ok: true,
         value: {
             type: type.toUpperCase(), name: name.toUpperCase(),
+            // F3 / M19: a person NAMED the level this decision's target is read from —
+            // `--target` on a fix or rebuild, `--level` on a keep or an exception.
+            // Only then does `decide` stamp `targetBy`; the default A is no target.
+            targetNamed: moves ? !!target.value : said.classification === 'keep' && !!level.value,
             row: {
                 classification: said.classification,
                 ...(said.exception ? { exception: true } : {}),
@@ -1271,17 +1933,24 @@ export function parseDecideArgs(args) {
                 // Spec §4.2: a fix or a rebuild reaches A unless the person says otherwise.
                 ...(moves ? { targetLevel: target.value ?? 'A' } : {}),
                 ...(reason ? { reason } : {}),
+                ...(kind ? { rebuildKind: kind } : {}),
+                ...(app ? { app } : {}),
             },
         },
     };
 }
 const DECISION_WORDS = { keep: 'keep', fix: 'fix', redesign: 'rebuild beside the core', retire: 'retire' };
-function decisionWords(row) {
+function decisionWords(row, targetNamed) {
     const parts = [row.exception ? 'accepted exception' : DECISION_WORDS[row.classification]];
     if (row.level)
         parts.push(`level ${row.level}`);
+    // Step 2 (F3): the default A is recorded but is no target, so it is not said as one.
     if (row.targetLevel)
-        parts.push(`target ${row.targetLevel}`);
+        parts.push(targetNamed ? `target ${row.targetLevel}` : 'no target set');
+    if (row.rebuildKind)
+        parts.push(REBUILD_KIND_WORDS[row.rebuildKind]);
+    if (row.app)
+        parts.push(`app ${row.app}`);
     return `${parts.join(', ')}${row.reason ? `, because: ${row.reason}` : ''}`;
 }
 function decide(args, deps) {
@@ -1289,16 +1958,144 @@ function decide(args, deps) {
     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 } : {}),
+    const { type, name, row, targetNamed } = parsed.value;
+    const now = (deps.now ?? (() => new Date()))();
+    const by = whoAmI(deps);
+    const res = writeRecord(joined, 'decision', [{
+            key: objectKey(type, name), ...row,
+            ...(targetNamed ? { targetBy: { name: by, at: now.toISOString() } } : {}),
+        }], { name: by }, {
+        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)}.`);
+    deps.print(`✓ Recorded: ${type} ${name} — ${decisionWords(row, targetNamed)}.`);
+    if (row.classification === 'retire')
+        deps.print('Recorded as a retire candidate. It becomes retired when the lead confirms it.');
+    refreshSheet(deps);
+    return 0;
+}
+// ── rebuild ─────────────────────────────────────────────────────────────────
+/**
+ * `cspeach team rebuild built <TYPE> <NAME> --app <APP>` (F9): a rebuild run by
+ * /abap-modernize reaches "built, not yet checked" by hand. `proven` is not
+ * written tonight: it needs a code-run ATC over the new objects.
+ */
+async function rebuildVerb(args, deps) {
+    const { REBUILD_USAGE, recordRebuildBuilt } = await import('../journey/rebuild.js');
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts))
+        if (name !== 'app')
+            throw new RegisterError(`--${name} is not an option of team rebuild.\n${REBUILD_USAGE}`);
+    const [word, type, name] = positional;
+    if (word?.toLowerCase() !== 'built' || !type || !name || positional.length !== 3 || !opts.app || opts.app === 'true')
+        throw new RegisterError(REBUILD_USAGE);
+    joinedOrThrow();
+    let line;
+    try {
+        line = recordRebuildBuilt({ type, name, app: opts.app }, whoAmI(deps), (deps.now ?? (() => new Date()))());
+    }
+    catch (e) {
+        throw new RegisterError(e instanceof Error ? e.message : String(e));
+    }
+    deps.print(line);
     refreshSheet(deps);
     return 0;
 }
+// ── target ──────────────────────────────────────────────────────────────────
+const TARGET_USAGE = 'Usage: cspeach team target <A|B|C|D> --reason "<why>" [--packages ZFI_AR,ZFI_GL] [--variant <NAME>]   |   cspeach team target clear [--packages …]';
+const TARGET_OPTIONS = ['reason', 'packages', 'variant'];
+const TARGET_PACKAGE = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,30}$/;
+const samePackages = (a, b) => (!a?.length && !b?.length) || (!!a && !!b && a.length === b.length && [...a].sort().join(',') === [...b].sort().join(','));
+/** The packages an entry is for, read loosely from the file (upper case), or undefined for the whole project. */
+function entryPackages(t) {
+    const p = t?.packages;
+    return Array.isArray(p) ? p.map((x) => String(x).trim().toUpperCase()) : undefined;
+}
+const forWhom = (packages) => (packages?.length ? packages.join(', ') : 'the whole team project');
+/**
+ * The project's target (spec §3.2, review I9): `target <L> --reason` sets the
+ * entry without packages; `--packages` (exact names, never a pattern) sets the
+ * entry for exactly that set; `clear` removes the matching entry. The whole
+ * project file is written, then renamed. A decision whose target a person set
+ * still comes first (register-core `targetOf`). `--variant` is stored only
+ * (F15): checks go on with the project's variant.
+ */
+function target(args, deps) {
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts)) {
+        if (!TARGET_OPTIONS.includes(name))
+            throw new RegisterError(`--${name} is not an option of team target.\n${TARGET_USAGE}`);
+    }
+    const [word] = positional;
+    const clearing = word?.toLowerCase() === 'clear';
+    const level = clearing ? undefined : levelOf((word ?? '').trim().toUpperCase());
+    if ((!clearing && !level) || positional.length !== 1)
+        throw new RegisterError(TARGET_USAGE);
+    const joined = joinedOrThrow();
+    const project = readProjectFile(joined.projectDir);
+    requireLead(project, deps);
+    let packages;
+    if (opts.packages !== undefined) {
+        const named = list(opts.packages === 'true' ? '' : opts.packages).map((p) => p.toUpperCase());
+        if (!named.length)
+            throw new RegisterError(`--packages needs package names.\n${TARGET_USAGE}`);
+        if (named.some((p) => /[*?%]/.test(p)))
+            throw new RegisterError('Name each package in full, for example ZFI_AR — not a pattern.');
+        const known = new Set(readBaseline(joined.projectDir).map((o) => o.package.toUpperCase()));
+        const unknown = named.find((p) => !TARGET_PACKAGE.test(p) || !known.has(p));
+        if (unknown)
+            throw new RegisterError(`${shown(unknown)} is not a package of this team project.`);
+        packages = [...new Set(named)].sort();
+    }
+    const existing = Array.isArray(project.target) ? [...project.target] : project.target ? [project.target] : [];
+    const at = existing.findIndex((t) => samePackages(entryPackages(t), packages));
+    let next = existing;
+    const out = [];
+    if (clearing) {
+        if (at < 0) {
+            deps.print(`Nothing to clear: no target is set for ${forWhom(packages)}.`);
+            return 0;
+        }
+        next = existing.filter((_, i) => i !== at);
+        out.push(`✓ Target cleared for ${forWhom(packages)}.${next.length ? '' : ' No target set — counted as the check reports.'}`);
+    }
+    else {
+        if (opts.reason === undefined || opts.reason === 'true')
+            throw new RegisterError('A target needs a reason: --reason "why this level is enough"');
+        const reason = Array.from(shownUpTo(opts.reason, Number.POSITIVE_INFINITY)).slice(0, MAX_REASON).join('').trim();
+        if (!reason)
+            throw new RegisterError('A target needs a reason: --reason "why this level is enough"');
+        let variant;
+        if (opts.variant !== undefined) {
+            variant = opts.variant === 'true' ? '' : opts.variant.trim().toUpperCase();
+            if (!VARIANT_NAME.test(variant))
+                throw new RegisterError(`"${shown(opts.variant === 'true' ? '' : opts.variant.trim())}" is not an ATC check variant name.`);
+        }
+        const entry = {
+            level, by: whoAmI(deps), at: (deps.now ?? (() => new Date()))().toISOString(), reason,
+            ...(packages ? { packages } : {}), ...(variant ? { variant } : {}),
+        };
+        next = at < 0 ? [...existing, entry] : existing.map((t, i) => (i === at ? entry : t));
+        out.push(`✓ Target: level ${level} for ${forWhom(packages)}. Reason recorded.`);
+        if (variant) {
+            out.push(`  Target ${level} — variant ${variant} (stored, not yet used for measuring). `
+                + `Checks still use ${(project.atcVariant ?? DEFAULT_ATC_VARIANT).trim().toUpperCase()}.`);
+        }
+    }
+    // The whole file, then renamed (review I9): one entry is written as an object, more as a list.
+    const { target: _old, ...rest } = readProjectFile(joined.projectDir);
+    const file = { ...rest, ...(next.length ? { target: next.length === 1 ? next[0] : next } : {}) };
+    writeWhole(path.join(joined.projectDir, TEAM_FILE), `${JSON.stringify(file, null, 2)}\n`);
+    for (const l of out)
+        deps.print(l);
+    return 0;
+}
+/** `team status`: one line per target in the project file, only when there is one (D1). */
+function targetLines(project) {
+    return targetsOf(project).map((t) => `Target ${t.level}${t.variant ? ` — variant ${t.variant} (stored, not yet used for measuring)` : ''}`
+        + `, for ${forWhom(t.packages)}. Set by ${shown(t.by)}.`);
+}
 // ── fixed ───────────────────────────────────────────────────────────────────
 const FIXED_USAGE = 'Usage: cspeach team fixed <TYPE> <NAME> [--rule <id>] [--transport <request>]';
 const utcLine = (iso) => `${iso.slice(0, 16).replace('T', ' ')} UTC`;
@@ -1377,28 +2174,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 {
@@ -1412,18 +2207,48 @@ function report(args, deps) {
             return false;
         }
     };
+    // The page this one replaces says when the last report was made, so the
+    // "changed since" block starts there. Read BEFORE it is overwritten.
+    const previousAsOf = previousAsOfIn(path.join(outDir, names.html));
     const saved = [
-        attempt(names.xlsx, () => writeXlsxFile(path.join(outDir, names.xlsx), combinedSheets(picture.register, asOf, folderName))) ? names.xlsx : null,
+        attempt(names.xlsx, () => writeXlsxFile(path.join(outDir, names.xlsx), combinedSheets(picture.register, asOf, folderName, project))) ? 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,
+            checksum: project.baseline?.sha256 ? 'ok' : 'not-checked', asOf, folderName, previousAsOf,
+            ...(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));
+    // D2: the CSV export rides along only when the project file switched it on.
+    if (exportsOn(project)) {
+        const out = writeExports(joined.projectDir, project, path.join(outDir, EXPORTS_DIR), deps);
+        if (out.saved.length)
+            deps.print('✓ Saved the CSV export in the exports folder beside the report.');
+        for (const name of out.held)
+            deps.print(heldExportLine(name));
+        held.push(...out.held);
+    }
     // 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');
@@ -1436,3 +2261,54 @@ function report(args, deps) {
     }
     return held.length ? 1 : 0;
 }
+// ── export ──────────────────────────────────────────────────────────────────
+const EXPORT_USAGE = 'Usage: cspeach team export [--out <folder>] [--always | --never]';
+const heldExportLine = (name) => `  ! "${name}" is open in another program, so it was not updated. Close it and run: cspeach team export`;
+/** The CSV export of the team project folder, as the team page reads it, into `dir`. */
+export function writeExports(projectDir, project, dir, deps) {
+    const { register } = registerFor(projectDir);
+    return writeExportFiles(register, project, dir, (deps.now?.() ?? new Date()).toISOString());
+}
+/**
+ * `team export [--out <folder>] [--always]` (spec §3.4, D2): the CSV files for
+ * the customer's own tools, on demand. Into `reports/exports` of the team
+ * project — the lead's folder, like the report — or the folder `--out` names,
+ * which anyone may. `--always` (lead only) switches on `"exports": { "csv": true }`
+ * in cspeach-team.json, so every report writes them too; `--never` (lead only)
+ * switches it off and writes no files.
+ */
+function exportVerb(args, deps) {
+    const { positional, opts } = flags(args, ['always', 'never']);
+    const always = opts.always === 'true';
+    const never = opts.never === 'true';
+    if (positional.length || Object.keys(opts).some((k) => k !== 'out' && k !== 'always' && k !== 'never') || opts.out === 'true'
+        || (always && never) || (never && opts.out !== undefined)) {
+        throw new RegisterError(EXPORT_USAGE);
+    }
+    const joined = joinedOrThrow();
+    const project = readProjectFile(joined.projectDir);
+    if (always || never || !opts.out)
+        requireLead(project, deps);
+    if (never) {
+        setExports(joined.projectDir, false);
+        deps.print('✓ Reports no longer write the CSV export ("exports": { "csv": false } in cspeach-team.json). cspeach team export still writes them when you ask.');
+        return 0;
+    }
+    if (always && !exportsOn(project))
+        setExports(joined.projectDir, true);
+    const dir = opts.out ? path.resolve(opts.out) : path.join(joined.projectDir, 'reports', EXPORTS_DIR);
+    const { saved, held } = writeExports(joined.projectDir, project, dir, deps);
+    const where = opts.out ? 'the folder you named' : 'the exports folder of the reports folder';
+    if (saved.length === 6)
+        deps.print(`✓ Saved the CSV export (4 CSV files, manifest.json and SCHEMA.md) in ${where}.`);
+    else if (saved.length)
+        deps.print(`✓ Saved ${saved.map((n) => `"${n}"`).join(', ')} in ${where}.`);
+    for (const name of held)
+        deps.print(heldExportLine(name));
+    if (always) {
+        deps.print(exportsOn(project)
+            ? '  The CSV export was already written with every report.'
+            : '✓ From now on every report writes the CSV export too ("exports": { "csv": true } in cspeach-team.json).');
+    }
+    return held.length ? 1 : 0;
+}