@cspeach/cli 1.1.31 → 1.1.33

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,19 +19,23 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { laneActiveOf, laneProvenOf, levelOf, normalizeRuleId, objectKey, } 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, 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 { 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'];
@@ -119,17 +124,21 @@ export async function runTeamCommand(args, 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|discover|focus|priority|plan|start   (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;
         }
     }
@@ -191,16 +200,67 @@ 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'];
+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']);
@@ -208,21 +268,48 @@ async function start(args, deps) {
         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)
+    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 : packages.join(', ');
+    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,
-        ...(opts['no-measure'] ? ['--no-measure'] : []), ...(opts['sap-alias'] && opts['sap-alias'] !== 'true' ? ['--sap-alias', opts['sap-alias']] : [])];
+        ...(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)
@@ -230,19 +317,62 @@ async function start(args, deps) {
         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);
+    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.`);
-    else if (opts['no-measure'])
+    // 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.');
-    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}`);
+    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) {
@@ -283,6 +413,18 @@ ${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);
@@ -316,8 +458,8 @@ ${INIT_USAGE}`);
         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)
@@ -347,11 +489,19 @@ ${INIT_USAGE}`);
             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
@@ -421,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');
@@ -454,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),
@@ -497,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.
@@ -515,13 +670,93 @@ function join(args, deps, asName) {
     // 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>');
+    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) {
@@ -551,6 +786,8 @@ async 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_*"] [--reason "<why>"]  |  lane remove <id> [--reason "<why>"]  |  lane propose --developers "…"');
@@ -566,7 +803,7 @@ async function lane(args, deps) {
         return 0;
     }
     if (verb !== 'add')
-        throw new RegisterError('lane: use add, remove, list or propose.');
+        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.');
@@ -588,12 +825,75 @@ async function lane(args, deps) {
         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();
@@ -604,53 +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})`);
-    // 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
-    // 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.');
-    deps.print(nowLine(r));
+    // 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(laneActiveOf(l)).padStart(6)} ${String(laneProvenOf(l)).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)}`);
         }
-        // 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'}`);
+        // 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('');
@@ -1043,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.');
@@ -1052,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
@@ -1284,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
@@ -1298,7 +1620,7 @@ async function refresh(args, deps) {
         return 2;
     }
     if (opts.perPackage)
-        return refreshPerPackage({ joined, project, baseline, lanes, inScope, variant, foreign, persist, atc, opts }, deps);
+        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, () => {
@@ -1322,6 +1644,7 @@ async function refresh(args, deps) {
             ...(foreign || persist ? { forceVariant: true } : {}),
             signal: stop.signal,
             confirmAbsent: true,
+            sql,
             onProgress: progressLine(deps),
         });
     }
@@ -1382,7 +1705,7 @@ async function refresh(args, deps) {
  * 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 { 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),
@@ -1396,8 +1719,11 @@ async function refreshPerPackage(input, deps) {
                 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)
+                && c.measured + (c.unsupported ?? 0) + (c.absent ?? 0) >= c.asked
+                && !(pass && pass.skipped > 0) && (pass?.notChecked ?? 0) === 0)
                 done.add(run.scope);
         }
     }
@@ -1438,12 +1764,16 @@ async function refreshPerPackage(input, deps) {
                 ...(opts.oneByOne ? {} : { oneByOne: false }),
                 ...(foreign || persist ? { forceVariant: true } : {}),
                 confirmAbsent: true,
+                ...(sql ? { sql } : {}),
                 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)}`);
+                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.`);
@@ -1531,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' },
@@ -1576,10 +1909,23 @@ export function parseDecideArgs(args) {
     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 } : {}),
@@ -1587,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) {
@@ -1605,18 +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`;
@@ -1728,11 +2207,14 @@ export function writeReports(projectDir, project, outDir, 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);
@@ -1758,6 +2240,15 @@ function report(args, deps) {
         deps.print(`✓ Saved ${saved.map((n) => `"${n}"`).join(' and ')} in ${where}.`);
     for (const name of held)
         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');
@@ -1770,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;
+}