@cspeach/cli 1.1.28 → 1.1.30

package/dist/agent/loop.js

@@ -291,9 +291,12 @@ export async function maybeOfferSave(p) {
     // logged so the transcript stays honest about who said yes.
     //
     // CONTRACT: this headless prompt blanket-answers 'y' to ANY question it
-    // is asked, so runSaveCommand must ask at most ONE question (the save
-    // confirm). See the matching note at the prompt site in
-    // src/projects/save-command.ts before adding further prompts there.
+    // is asked, so `prompt` may carry only ONE question (the save confirm).
+    // runSaveCommand asks 1+N cards: the save confirm, then (clean-core
+    // decisions) one card per row — and the row cards go through `confirm`
+    // only, never `prompt`, so a headless run confirms no row. See the
+    // matching note at the prompt site in src/projects/save-command.ts
+    // before adding further prompts there.
     const { isHeadless } = await import('../renderer/tty.js');
     const prompt = isHeadless()
         ? async (q) => {

package/dist/agent/turn-error-ux.js

@@ -82,6 +82,33 @@ function describeApiError(err, msg) {
     const label = status ? `service error ${status}` : 'service error';
     return (text ? `${label}: ${text}` : label).slice(0, 200);
 }
+/**
+ * The proxy's `409 {"error":"upgrade_required",min_cli_version,current}`, from
+ * the SDK error's parsed `.error` body or, failing that, its message text.
+ */
+function upgradeRequired(err) {
+    const e = err;
+    let body = e && typeof e.error === 'object' ? e.error : null;
+    if (body?.error !== 'upgrade_required') {
+        const msg = typeof e?.message === 'string' ? e.message : '';
+        const brace = msg.indexOf('{');
+        if (!/^409\b/.test(msg) || brace < 0)
+            return null;
+        try {
+            body = JSON.parse(msg.slice(brace, msg.lastIndexOf('}') + 1));
+        }
+        catch {
+            return null;
+        }
+        if (body?.error !== 'upgrade_required')
+            return null;
+    }
+    if (e?.status != null && e.status !== 409)
+        return null;
+    const min = typeof body.min_cli_version === 'string' ? body.min_cli_version : 'a newer version';
+    const current = typeof body.current === 'string' ? body.current : 'an older version';
+    return { min, current };
+}
 /**
  * Write a full diagnostic log to ~/.cspeach/logs/<sessionId>-<ts>.log.
  * Best-effort — failure here is silent, the user-facing block still renders.
@@ -164,6 +191,19 @@ export async function renderTurnError(input) {
         print('');
         return;
     }
+    // 1.1.29 — the proxy's 409 upgrade_required (skill needs a newer CLI). It
+    // reaches here, not loop.ts's create-time check: the SDK raises it while
+    // the stream is read. "type continue" would only repeat the 409.
+    const upgrade = upgradeRequired(input.err);
+    if (upgrade) {
+        printBlock(print, formatFailure({
+            what: 'This needs a newer CSPeach',
+            detail: [`needs ${upgrade.min} or later · you have ${upgrade.current}`],
+            next: input.inSession ? 'type /exit, then run: cspeach --upgrade' : 'cspeach --upgrade',
+        }));
+        print('');
+        return;
+    }
     const reason = describeError(input.err);
     const logPath = await writeErrorLog(id, input.err);
     const detail = [reason, `Session: ${id}`];

package/dist/auth/auth-file.js

@@ -202,9 +202,9 @@ export async function migrateLegacyByokKey(deps) {
 export function legacyByokKeyNotice(outcome) {
     switch (outcome) {
         case 'conflict':
-            return 'cspeach: ~/.cspeach/auth.json still holds a pasted Anthropic API key in plain text that is different from the one in your OS keychain (the one CSPeach uses). It was kept in case it is your only copy — remove the "byokAnthropicKey" line from auth.json once you no longer need it.';
+            return 'cspeach: auth.json in your CSPeach home still holds a pasted Anthropic API key in plain text that is different from the one in your OS keychain (the one CSPeach uses). It was kept in case it is your only copy — remove the "byokAnthropicKey" line from auth.json once you no longer need it.';
         case 'keychain-unavailable':
-            return 'cspeach: ~/.cspeach/auth.json still holds your Anthropic API key in plain text — the OS keychain is not available, so it could not be moved there (on Linux: install and unlock a Secret Service keyring such as gnome-keyring). CSPeach will move it on the next start once the keychain works.';
+            return 'cspeach: auth.json in your CSPeach home still holds your Anthropic API key in plain text — the OS keychain is not available, so it could not be moved there (on Linux: install and unlock a Secret Service keyring such as gnome-keyring). CSPeach will move it on the next start once the keychain works.';
         default:
             return null;
     }

package/dist/cli.js

@@ -290,6 +290,10 @@ Usage:
   cspeach team status [folder]      Where every object stands, who owns it, what is proven
   cspeach team outbox               What this laptop has recorded, and where
   cspeach team rule T N <d>         Lead: settle a conflicting decision
+  cspeach team decide T N <d>       Record a clean-core decision: keep, fix, rebuild, retire or exception
+  cspeach team fixed T N            Claim a fix; the next refresh checks it
+  cspeach team sheet                Write your working list (Excel) from the team project
+  cspeach team report               Lead: the combined workbook and status page, in reports
   cspeach team leave                Stop recording
   cspeach analyze project-context   Compare flag-on vs flag-off session metrics
   cspeach --upgrade                 Upgrade to latest via npm

package/dist/commands/login.js

@@ -97,7 +97,7 @@ export async function runLoginCommand(deps) {
         apiKey: polled.api_key,
         customerId: polled.customer_id,
     });
-    deps.print(done('Saved your CSPeach key to ~/.cspeach/auth.json'));
+    deps.print(done('Saved your CSPeach key to auth.json in your CSPeach home'));
     // 6) /v1/me — figure out if BYOK is required.
     try {
         const r = await fetch(`${proxy}/v1/me`, { headers: { Authorization: `Bearer ${polled.api_key}` } });

package/dist/commands/logout.js

@@ -10,7 +10,7 @@ export async function runLogoutCommand(deps) {
     const before = await readAuthFile();
     await deleteAuthFile();
     if (before) {
-        deps.print(`${paint('ok', getGlyphs().done)} Signed out · removed ~/.cspeach/auth.json`);
+        deps.print(`${paint('ok', getGlyphs().done)} Signed out · removed auth.json from your CSPeach home`);
         deps.print(`  ${paint('dim', 'The REPL uses the keychain-stored key if you have one.')}`);
         deps.print(`  ${paint('dim', 'Next:')} cspeach login   (to sign in again)`);
     }

package/dist/commands/team.js

@@ -18,12 +18,18 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { activeOf, buildRegister, narrowedLanes, objectKey, provenOf, } from '@cspeach/register-core';
+import { activeOf, levelOf, normalizeRuleId, objectKey, provenOf, } from '@cspeach/register-core';
 import { LOCAL_PACKAGE, listCustomPackages, pullBaseline, BaselineError } from '../register/baseline.js';
-import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, collectRecords, defaultOutboxDir, loadState, projectIdFor, readBaseline, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.js';
-import { measure, noVariantYetMessage, scopeLabel, scopeObjects, variantMismatchMessage, } from '../register/measure.js';
+import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, defaultOutboxDir, loadState, projectIdFor, readBaseline, 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 { 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';
 const CLASSIFICATIONS = ['keep', 'fix', 'retire', 'redesign'];
 const TYPES = ['clean-core', 'upgrade', 'build'];
 /**
@@ -38,6 +44,15 @@ const TYPES = ['clean-core', 'upgrade', 'build'];
  * the lead, and every record says who wrote it.
  */
 const whoAmI = (deps) => activeProject()?.name ?? deps.identity().name;
+/** After a record this laptop wrote: its working list, made again. One line, or none. */
+function refreshSheet(deps) {
+    const joined = activeProject();
+    if (!joined)
+        return;
+    const res = regenerateWorkingList(joined, whoAmI(deps), deps.now?.());
+    if (res.line)
+        deps.print(res.line);
+}
 /**
  * Names that are a machine's, not a person's. A team project whose lead is
  * "Admin" says nothing about who leads it, and the writer id, the rulings and
@@ -102,8 +117,12 @@ export async function runTeamCommand(args, deps) {
             case 'outbox': return outbox(rest, deps);
             case 'rule': return rule(rest, deps);
             case 'leave': return leave(deps);
+            case 'decide': return decide(rest, deps);
+            case 'fixed': return await fixed(rest, deps);
+            case 'sheet': return sheet(deps);
+            case 'report': return report(rest, deps);
             default:
-                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave   (cspeach --help for details)');
+                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave|decide|fixed|sheet|report   (cspeach --help for details)');
                 return sub ? 1 : 0;
         }
     }
@@ -298,6 +317,7 @@ async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
         const res = await measure({
             joined: joinedOrThrow(), project, baseline, lanes: [], scope: { kind: 'all' }, variant, atc, by: { name: whoAmI(deps) },
             dir: path.join(dir, 'baseline'), fileName: 'measurement-0.json',
+            confirmAbsent: true,
             ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
             signal: stop.signal,
             onProgress: progressLine(deps),
@@ -312,7 +332,7 @@ async function firstMeasurement(dir, project, baseline, opts, atc, deps) {
         // line: this one record belongs to the team project, not to this laptop.
         if (res.file)
             deps.print('  This first measurement is part of the team project\'s baseline, in the shared folder.');
-        const stoppedBy = res.stoppedBy ?? (stop.signal.aborted ? 'aborted' : undefined);
+        const stoppedBy = res.stoppedBy ?? secondPassStop(res) ?? (stop.signal.aborted ? 'aborted' : undefined);
         if (stoppedBy) {
             const why = STOPPED_WORDS[stoppedBy];
             deps.print(res.file
@@ -418,24 +438,6 @@ function lane(args, deps) {
     return 0;
 }
 // ── status ──────────────────────────────────────────────────────────────────
-function registerFor(projectDir, outboxDir) {
-    const project = readProjectFile(projectDir);
-    const collected = collectRecords(projectDir);
-    // This laptop's own outbox counts too, so a developer sees their work before
-    // handing it in. It is also the one way this picture can legitimately differ
-    // from the team project page's, so `status` says out loud when it counted them.
-    const own = outboxDir && path.resolve(outboxDir) !== path.resolve(projectDir) ? collectRecords(outboxDir) : { records: [], unreadable: 0, files: 0 };
-    const baseline = readBaseline(projectDir);
-    const lanes = readLanes(projectDir);
-    const register = buildRegister({ project, baseline, lanes, records: [...collected.records, ...own.records] });
-    return {
-        register, files: collected.files + own.files,
-        unreadable: collected.unreadable + own.unreadable, ownFiles: own.files,
-        // F2: a lanes.json written before names began to narrow packages holds
-        // fewer objects now. The lead is told, not left to work it out from a count.
-        narrowed: narrowedLanes(lanes, baseline),
-    };
-}
 const STATE_WORDS = [
     ['verified', 'verified'], ['clean', 'clean'], ['claimed', 'claimed, not measured since'], ['working', 'in work'],
     ['decided', 'decided, not started'], ['untouched', 'untouched'], ['did-not-hold', 'fix did not hold'],
@@ -805,9 +807,49 @@ export const absentLine = (count, names) => [
         + `${count === 1 ? 'It is' : 'They are'} left as not measured.`,
     ...(names.length ? [`    ${someNames(names)}`] : []),
 ];
+/**
+ * R-1, said plainly: how many silent objects were checked again on their own,
+ * and — for the ones that were not — the true reason. An object the second pass
+ * skipped or never finished gets THIS reason, never the variant's.
+ */
+function secondPassLines(res, deps) {
+    const pass = res.secondPass;
+    if (!pass)
+        return;
+    if (pass.asked) {
+        deps.print(`  ${plural(pass.asked, 'object the run did not list was', 'objects the run did not list were')} checked again on `
+            + `${pass.asked === 1 ? 'its' : 'their'} own: ${pass.listed} listed.`);
+    }
+    const n = pass.notChecked ?? 0;
+    const own = n === 1 ? 'on its own and stays' : 'on their own and stay';
+    if (pass.stopped) {
+        const why = STOPPED_WORDS[pass.stopped];
+        deps.print(n
+            ? `  ! Checking those objects one by one ${why} before it finished: ${plural(n, 'object was', 'objects were')} not checked again ${own} not measured.`
+            : `  ! Checking those objects one by one ${why} before it finished.`);
+    }
+    else if (n) {
+        deps.print(`  ! ${plural(n, 'object was', 'objects were')} not checked again: ${n === 1 ? 'its own check' : 'their own checks'} did not finish. `
+            + `${n === 1 ? 'It stays' : 'They stay'} not measured.`);
+    }
+    if (pass.skipped && pass.skippedBy === 'time') {
+        deps.print(`  ! ${plural(pass.skipped, 'object the run did not list was', 'objects the run did not list were')} not checked again on `
+            + `${pass.skipped === 1 ? 'its' : 'their'} own: the time budget ran out first. ${pass.skipped === 1 ? 'It stays' : 'They stay'} not measured.`);
+    }
+    else if (pass.skipped) {
+        deps.print(`  ! ${plural(pass.skipped, 'more object was', 'more objects were')} not checked again `
+            + `(one measurement checks up to ${MAX_SECOND_PASS} on their own). Narrow the run with --lane or --packages to check the rest.`);
+    }
+    if ((n || pass.skipped) && res.notCheckedNames?.length)
+        deps.print(`    ${someNames(res.notCheckedNames)}`);
+}
 function notMeasuredLines(res, deps, words = {}) {
-    if (res.absent) {
-        for (const line of words.absentLines?.(res.absent) ?? absentLine(res.absent, res.absentNames))
+    // Objects the second pass skipped or never finished were said above, with
+    // their own reason. Only the rest are the variant's silence.
+    const unchecked = new Set(res.notCheckedNames ?? []);
+    const silent = Math.max(0, res.absent - (res.secondPass?.skipped ?? 0) - (res.secondPass?.notChecked ?? 0));
+    if (silent) {
+        for (const line of words.absentLines?.(silent) ?? absentLine(silent, res.absentNames.filter((k) => !unchecked.has(k))))
             deps.print(line);
     }
     for (const c of res.refusedChunks) {
@@ -826,10 +868,12 @@ export function reportMeasurement(res, variant, deps, foreignTo, words = {}) {
         deps.print(words.nothing ?? '✗ Nothing was measured, so nothing was written.');
         for (const note of words.notes ?? [])
             deps.print(note);
+        secondPassLines(res, deps);
         notMeasuredLines(res, deps, words);
         return;
     }
     deps.print(words.headline ?? `✓ ${plural(res.measured, 'object measured', 'objects measured')}, ${res.withFindings} with findings.`);
+    secondPassLines(res, deps);
     // F3: SAP reports some findings twice — same place, same message, two finding
     // ids. One problem in the code is one finding, so it is counted once; a
     // person comparing this with their own ATC screen has to be told why the two
@@ -850,6 +894,11 @@ export function reportMeasurement(res, variant, deps, foreignTo, words = {}) {
     deps.print(`  Written to ${res.file}`);
     deps.print('  Next: cspeach team status');
 }
+/**
+ * A second pass that was cut short, or never had time to start, leaves objects
+ * not checked again: the measurement is partial, and the exit code says so.
+ */
+const secondPassStop = (res) => res.secondPass?.stopped ?? (res.secondPass?.skippedBy === 'time' && res.secondPass.skipped ? 'deadline' : undefined);
 /** Why a run ended before it reached the end of the set, in plain words. */
 const STOPPED_WORDS = {
     deadline: 'ran out of time',
@@ -998,6 +1047,7 @@ function refreshFromFile(opts, deps) {
     });
     if (!res.file)
         return 1;
+    refreshSheet(deps);
     // Live evidence outranks file evidence, per object. An import that changes no
     // state is legal and is kept — but nobody should have to work that out from
     // the picture afterwards, and no closing line may read as a fresh measurement.
@@ -1079,6 +1129,7 @@ async function refresh(args, deps) {
             // the lead's first run, whose name is not on disk yet.
             ...(foreign || persist ? { forceVariant: true } : {}),
             signal: stop.signal,
+            confirmAbsent: true,
             onProgress: progressLine(deps),
         });
     }
@@ -1086,6 +1137,8 @@ async function refresh(args, deps) {
         off();
     }
     reportMeasurement(res, variant, deps, foreign ? (project.atcVariant ?? '').trim().toUpperCase() : undefined);
+    if (res.file)
+        refreshSheet(deps);
     // The picture, once, for the two things said after the report. Built lazily:
     // a refresh that measured nothing and reported nothing does not need it.
     let merged = null;
@@ -1111,7 +1164,7 @@ async function refresh(args, deps) {
                 + `Ask the lead to try again: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
-    const stoppedBy = res.stoppedBy ?? (stop.signal.aborted ? 'aborted' : undefined);
+    const stoppedBy = res.stoppedBy ?? secondPassStop(res) ?? (stop.signal.aborted ? 'aborted' : undefined);
     if (stoppedBy) {
         const why = STOPPED_WORDS[stoppedBy];
         deps.print(res.file
@@ -1164,3 +1217,222 @@ function rule(args, deps) {
     deps.print(`✓ Ruled ${objectKey(type, name)} = ${classification}.`);
     return 0;
 }
+// ── decide ──────────────────────────────────────────────────────────────────
+const DECIDE_USAGE = 'Usage: cspeach team decide <TYPE> <NAME> keep|fix|retire|rebuild|exception [--level A-D] [--target A-D] [--reason "<why>"]';
+const DECIDE_OPTIONS = ['level', 'target', 'reason'];
+/** The five words a person types, onto the four classifications the files hold (spec §4.2). */
+const DECIDE_WORDS = {
+    keep: { classification: 'keep' },
+    exception: { classification: 'keep', exception: true },
+    fix: { classification: 'fix' },
+    rebuild: { classification: 'redesign' },
+    redesign: { classification: 'redesign' },
+    retire: { classification: 'retire' },
+};
+const MAX_REASON = 300;
+export function parseDecideArgs(args) {
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts)) {
+        if (!DECIDE_OPTIONS.includes(name))
+            return { ok: false, message: `--${name} is not an option of team decide.\n${DECIDE_USAGE}` };
+    }
+    const [type, name, word] = positional;
+    const said = word ? DECIDE_WORDS[word.toLowerCase()] : undefined;
+    if (!type || !name || !said || positional.length > 3)
+        return { ok: false, message: DECIDE_USAGE };
+    const letter = (flag) => {
+        if (opts[flag] === undefined)
+            return { ok: true };
+        const value = levelOf(opts[flag].trim().toUpperCase());
+        return value ? { ok: true, value } : { ok: false };
+    };
+    const level = letter('level');
+    const target = letter('target');
+    if (!level.ok || !target.ok)
+        return { ok: false, message: 'A level is one of A, B, C or D. A uses only released APIs; D modifies SAP standard.' };
+    const moves = said.classification === 'fix' || said.classification === 'redesign';
+    if (target.value && !moves)
+        return { ok: false, message: 'A target level only goes with fix or rebuild.' };
+    if (opts.reason === 'true')
+        return { ok: false, message: '--reason needs words, for example: --reason "reads BSID directly"' };
+    const reason = (opts.reason ?? '').trim();
+    if (reason.length > MAX_REASON)
+        return { ok: false, message: `Keep the reason under ${MAX_REASON} characters.` };
+    if (said.exception && !reason)
+        return { ok: false, message: 'An accepted exception needs a reason: --reason "<why it stays>"' };
+    return {
+        ok: true,
+        value: {
+            type: type.toUpperCase(), name: name.toUpperCase(),
+            row: {
+                classification: said.classification,
+                ...(said.exception ? { exception: true } : {}),
+                ...(level.value ? { level: level.value } : {}),
+                // Spec §4.2: a fix or a rebuild reaches A unless the person says otherwise.
+                ...(moves ? { targetLevel: target.value ?? 'A' } : {}),
+                ...(reason ? { reason } : {}),
+            },
+        },
+    };
+}
+const DECISION_WORDS = { keep: 'keep', fix: 'fix', redesign: 'rebuild beside the core', retire: 'retire' };
+function decisionWords(row) {
+    const parts = [row.exception ? 'accepted exception' : DECISION_WORDS[row.classification]];
+    if (row.level)
+        parts.push(`level ${row.level}`);
+    if (row.targetLevel)
+        parts.push(`target ${row.targetLevel}`);
+    return `${parts.join(', ')}${row.reason ? `, because: ${row.reason}` : ''}`;
+}
+function decide(args, deps) {
+    const parsed = parseDecideArgs(args);
+    if (!parsed.ok)
+        throw new RegisterError(parsed.message);
+    const joined = joinedOrThrow();
+    const { type, name, row } = parsed.value;
+    const res = writeRecord(joined, 'decision', [{ key: objectKey(type, name), ...row }], { name: whoAmI(deps) }, {
+        ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
+    });
+    if (!res.file)
+        throw new RegisterError(`${type} ${name} is not in this team project's object list.`);
+    deps.print(`✓ Recorded: ${type} ${name} — ${decisionWords(row)}.`);
+    refreshSheet(deps);
+    return 0;
+}
+// ── fixed ───────────────────────────────────────────────────────────────────
+const FIXED_USAGE = 'Usage: cspeach team fixed <TYPE> <NAME> [--rule <id>] [--transport <request>]';
+const utcLine = (iso) => `${iso.slice(0, 16).replace('T', ' ')} UTC`;
+/**
+ * "I fixed this" — a claim, matched to a finding by (object, rule). It moves no
+ * colour to proven: only the next measurement does (spec §4.3).
+ */
+async function fixed(args, deps) {
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts)) {
+        if (name !== 'rule' && name !== 'transport')
+            throw new RegisterError(`--${name} is not an option of team fixed.\n${FIXED_USAGE}`);
+    }
+    const [rawType, rawName] = positional;
+    if (!rawType || !rawName || positional.length > 2)
+        throw new RegisterError(FIXED_USAGE);
+    const type = rawType.toUpperCase();
+    const name = rawName.toUpperCase();
+    const joined = joinedOrThrow();
+    const key = objectKey(type, name);
+    if (!readBaseline(joined.projectDir).some((o) => objectKey(o.type, o.name) === key)) {
+        // `shown()`: the person's own arguments, still printed through CSPeach.
+        throw new RegisterError(`${shown(type)} ${shown(name)} is not in this team project's object list.`);
+    }
+    let transport;
+    if (opts.transport !== undefined) {
+        transport = opts.transport === 'true' ? '' : opts.transport.trim().toUpperCase();
+        if (!/^[A-Z0-9]{1,20}$/.test(transport))
+            throw new RegisterError('--transport needs the request number, for example: --transport S4HK903500');
+    }
+    let rules;
+    if (opts.rule !== undefined) {
+        const rule = opts.rule === 'true' ? '' : normalizeRuleId(opts.rule);
+        if (!rule)
+            throw new RegisterError('--rule needs the rule id, for example: --rule "API:BSID"');
+        rules = [rule];
+    }
+    else {
+        const f = findingsByObject(joined.projectDir, joined.outboxDir).get(key);
+        if (!f?.latestAt)
+            throw new RegisterError('Nothing measured yet to claim against; name the rule with --rule.');
+        if (!f.latest.length) {
+            deps.print(`Nothing is open for ${type} ${name} at its last measurement (${utcLine(f.latestAt)}). Nothing was recorded.`);
+            return 0;
+        }
+        deps.print(`Open for ${type} ${name} at its last measurement, ${utcLine(f.latestAt)}:`);
+        for (const r of f.latest.slice(0, 10))
+            deps.print(`  ${r.count}× ${r.rule}${r.message ? ` — ${r.message}` : ''}`);
+        if (f.latest.length > 10)
+            deps.print(`  and ${f.latest.length - 10} more`);
+        if (!deps.ask)
+            throw new RegisterError('Marking findings fixed needs a yes. In a script, name each rule with --rule.');
+        const total = f.latest.reduce((n, r) => n + r.count, 0);
+        const answer = (await deps.ask(`Mark these ${plural(total, 'finding', 'findings')} as fixed? [y/n]`)).trim().toLowerCase();
+        if (answer !== 'y' && answer !== 'yes') {
+            deps.print('Nothing was recorded.');
+            return 1;
+        }
+        rules = f.latest.map((r) => r.rule);
+    }
+    writeRecord(joined, 'fix', rules.map((rule) => ({ key, rule, status: 'fixed', ...(transport ? { transport } : {}) })), { name: whoAmI(deps) }, { ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}) });
+    deps.print(`✓ Claimed: ${type} ${name}, ${plural(rules.length, 'rule', 'rules')} marked fixed. A claim is not proof — the next cspeach team refresh checks it.`);
+    refreshSheet(deps);
+    return 0;
+}
+// ── sheet ───────────────────────────────────────────────────────────────────
+function sheet(deps) {
+    const joined = joinedOrThrow();
+    const res = regenerateWorkingList(joined, whoAmI(deps), deps.now?.());
+    if (!res.ownsLane) {
+        deps.print('You own no lane in this team project, so there is no working list to write. The lead adds lanes with: cspeach team lane add');
+        return 0;
+    }
+    if (res.line)
+        deps.print(res.line.trimStart());
+    return res.file ? 0 : 1;
+}
+// ── report ──────────────────────────────────────────────────────────────────
+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 picture = registerFor(joined.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 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.
+    const held = [];
+    const attempt = (name, write) => {
+        try {
+            write();
+            return true;
+        }
+        catch (e) {
+            if (!HELD.has(e?.code ?? ''))
+                throw e;
+            held.push(name);
+            return false;
+        }
+    };
+    const saved = [
+        attempt(names.xlsx, () => writeXlsxFile(path.join(outDir, names.xlsx), combinedSheets(picture.register, asOf, folderName))) ? names.xlsx : null,
+        attempt(names.html, () => writeWhole(path.join(outDir, names.html), statusHtmlFor({
+            project, register: picture.register, files: picture.files, unreadable: picture.unreadable,
+            checksum: project.baseline?.sha256 ? 'ok' : 'not-checked', asOf, folderName,
+        }))) ? names.html : null,
+    ].filter((n) => n !== null);
+    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`);
+    // Records on this laptop that have not reached the folder are not in the report.
+    const ownDir = path.join(joined.outboxDir, 'writers', joined.writerId, 'records');
+    const inFolder = path.join(joined.projectDir, 'writers', joined.writerId, 'records');
+    if (path.resolve(ownDir) !== path.resolve(inFolder) && fs.existsSync(ownDir)) {
+        const missing = fs.readdirSync(ownDir).filter((f) => f.endsWith('.json') && !fs.existsSync(path.join(inFolder, f))).length;
+        if (missing) {
+            deps.print(`  ${plural(missing, 'record file on this laptop is', 'record files on this laptop are')} not in the team project folder yet, `
+                + `so ${missing === 1 ? 'it is' : 'they are'} not in this report.`);
+        }
+    }
+    return held.length ? 1 : 0;
+}

package/dist/commands/whoami.js

@@ -15,7 +15,7 @@ const serverText = (v) => sanitizeControlChars(String(v ?? '')).replace(/\s*\r?\
 export async function runWhoamiCommand(deps) {
     const auth = await readAuthFile();
     if (!auth) {
-        deps.print(formatInfo('Not signed in with cspeach login (no ~/.cspeach/auth.json)').trimEnd());
+        deps.print(formatInfo('Not signed in with cspeach login (no auth.json in your CSPeach home)').trimEnd());
         deps.print(`  ${paint('dim', 'Next:')} cspeach login   (the REPL may still use a keychain key — run cspeach to check)`);
         return 0;
     }

package/dist/config/paths.js

@@ -1,8 +1,22 @@
 import path from 'node:path';
 import os from 'node:os';
-export function cspeachRoot() {
+/** `~/.cspeach` — where CSPeach lives unless CSPEACH_HOME says otherwise. */
+export function defaultCspeachRoot() {
     return path.join(os.homedir(), '.cspeach');
 }
+/**
+ * The CLI home. `CSPEACH_HOME` moves it (two seats on one machine — spec
+ * 2026-10-06 §8); blank or unset keeps `~/.cspeach`. A drive root (`C:\`,
+ * `/`) is never accepted: it has no folder name, so the file tools' home
+ * denylist (which matches the home's own folder name) could not hold it.
+ */
+export function cspeachRoot() {
+    const chosen = process.env.CSPEACH_HOME?.trim();
+    if (!chosen)
+        return defaultCspeachRoot();
+    const resolved = path.resolve(chosen);
+    return path.basename(resolved) ? resolved : defaultCspeachRoot();
+}
 export function configFile() {
     return path.join(cspeachRoot(), 'config.toml');
 }

package/dist/one-shot.js

@@ -68,6 +68,7 @@ import './tools/project/playbook_get.js';
 import './tools/project/convention_get.js';
 import './tools/project/cca_merge.js';
 import './tools/project/upgrade_merge_progress.js';
+import './tools/project/team_findings.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';

package/dist/projects/clean-core-confirm.js

@@ -0,0 +1,36 @@
+const WORD = {
+    keep: 'keep', exception: 'accepted exception', fix: 'fix', rebuild: 'rebuild beside the core', retire: 'retire',
+};
+export function rowWords(r) {
+    const parts = [WORD[r.disposition]];
+    if (r.level)
+        parts.push(`level ${r.level}`);
+    if (r.disposition === 'fix' || r.disposition === 'rebuild')
+        parts.push(`target ${r.targetLevel ?? 'A'}`);
+    return `${parts.join(', ')}${r.reason ? `, because: ${r.reason}` : ''}`;
+}
+const DECIDE_HINT = 'cspeach team decide <TYPE> <NAME> <decision>';
+export async function confirmCleanCoreRows(ex, a) {
+    if (!a.joined) {
+        // Review Focus 4: the file is still saved; say why nothing is recorded.
+        a.log('Not recorded for a team project: this laptop has not joined one. To record these decisions, join with: cspeach team join <folder>');
+        return ex;
+    }
+    if (!a.confirm) {
+        a.log(`Not recorded for the team project: each row needs a yes, and this session cannot ask. Record them with: ${DECIDE_HINT}`);
+        return ex;
+    }
+    const rows = [];
+    for (const r of ex.content.adjudications) {
+        const answer = await a.confirm(`Record ${r.objectType} ${r.objectName}: ${rowWords(r)}?`, { default: 'n' });
+        rows.push({ ...r, confirmed: answer === 'y' });
+    }
+    const yes = rows.filter((r) => r.confirmed).length;
+    a.log(`${yes} of ${rows.length} rows confirmed. To record a row differently: ${DECIDE_HINT}`);
+    const byId = new Map(rows.map((r) => [r.id, r.confirmed]));
+    return {
+        ...ex,
+        content: { ...ex.content, adjudications: rows },
+        items: ex.items.map((i) => ({ ...i, status: byId.get(i.id) ? 'confirmed' : 'declined' })),
+    };
+}