@cspeach/cli 1.1.30 → 1.1.32

package/dist/journey/run.js

@@ -0,0 +1,628 @@
+/**
+ * Guided clean-core journey, Task 2 — run one stage
+ * (design .superpowers/sdd/guided-journey-design.md §1, §2, §4).
+ *
+ * The code stages run the `team` command bodies in process, their output kept
+ * back, and say a few plain lines of their own. The model stages (DECIDE, FIX)
+ * are not run here: the runner builds the slash command from the register and
+ * hands it back for the loop to queue. Nothing here touches the REPL or the
+ * loop, nothing throws, and every path returns lines plus the next action.
+ *
+ * Solo words only on screen: never "team", "lane", "outbox" or "join" — except
+ * inside a slash command the journey queues or names.
+ */
+import path from 'node:path';
+import { estateSummaryOf, provenForTargetWords, usageLineWithWindow } from '@cspeach/register-core';
+import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, ownerMatch, runTeamCommand, severalLine, whoAmI, writeExports, writeReports } from '../commands/team.js';
+import { EXPORTS_DIR, exportsOn, setExportsAlways } from '../register/export-files.js';
+import { shown, shownUpTo } from '../register/atc-file.js';
+import { activeProject, readEstate, readLanes, readProjectFile, VARIANT_NAME } from '../register/store.js';
+import { registerFor } from '../register/picture.js';
+import { claimedSinceCheck, fixFailedCheck, myObjects, provenForTarget, readJourneyFacts, stepOf, toDecide, toFix, toProve, toRedesign, unreadableReason, STEPS, } from './clean-core.js';
+/* ── words ──────────────────────────────────────────────────────────────── */
+export const UNREADABLE_LINES = {
+    'object-list': 'The project\'s object list in this folder can\'t be read right now — it may still be syncing. Try again in a minute.',
+    'project-file': 'This folder\'s project file can\'t be read.',
+    other: 'This folder can\'t be read right now.',
+};
+const step = (stage, title) => `Step ${stepOf(stage)} of ${STEPS} — ${title}`;
+const plural = (count, one, many) => `${count.toLocaleString('en-US')} ${count === 1 ? one : many}`;
+const minutes = (objects) => {
+    // About 25 objects a minute (live measurement 2026-10-07), never under one minute.
+    const m = Math.max(1, Math.ceil(objects / 25));
+    return `About ${plural(m, 'minute', 'minutes')}.`;
+};
+/** Words a solo person never reads, and anything that looks like a path or a command to type. */
+const NOT_SOLO = /\b(team|lanes?|outbox(es)?|join(s|ed|ing)?|writers?|variant|projectId|claim(s|ed|ing)?)\b/i;
+// Unix paths bare, quoted or bracketed ('/Users/x/y.json'), and home paths (~/x).
+const LOOKS_LIKE_PATH = /[A-Za-z]:\\|\\\\|(^|[\s"'`(])\/[^\s"'`)]*\/|~\/|cspeach\s/i;
+export const NO_SAP_LINE = 'No SAP system is connected in this session.';
+const NO_ATC_LINE = "SAP's code checks can't be run from this session.";
+const ALREADY_LINE = 'This folder already holds a project. Say carry on to work in it.';
+/**
+ * The failures CSPeach knows, each in its own plain words. "Cannot measure"
+ * comes first: a session without SAP is said before any step runs, so here it
+ * means the connection offers no ATC.
+ */
+const KNOWN = [
+    [/cannot measure/i, NO_ATC_LINE],
+    [/No SAP system is configured|needs a SAP connection/i, NO_SAP_LINE],
+    [/already holds a team project/i, ALREADY_LINE],
+];
+/**
+ * What to say when a team body failed: a known failure in its own words;
+ * else its first error, when that reads as a plain sentence; else `fallback`.
+ * Never a path, never a word a solo person does not use.
+ */
+export function failureLine(said, fallback) {
+    for (const line of said)
+        for (const [re, words] of KNOWN)
+            if (re.test(line))
+                return words;
+    const first = said.find((l) => l.startsWith('✗'))?.replace(/^✗\s*/, '').trim();
+    if (!first || NOT_SOLO.test(first) || LOOKS_LIKE_PATH.test(first))
+        return fallback;
+    return shown(first);
+}
+const failure = failureLine;
+/**
+ * A decision record that could not be written, inside a journey: "Not
+ * recorded: <plain reason>." The reason as it was said when it reads as a
+ * plain sentence; never a path, a team word or a command.
+ */
+export function notRecordedLine(error) {
+    const said = error instanceof Error ? error.message : String(error);
+    const plain = failureLine([`✗ ${said}`], 'the record could not be written to this folder').replace(/[\s.…]+$/, '');
+    return `Not recorded: ${plain}.`;
+}
+/** An object name to show: as it is when it is an ABAP name, cleaned otherwise. */
+export const objectShown = (name) => (OBJECT_NAME.test(name.toUpperCase()) ? name.toUpperCase() : shown(name));
+/** An object marked fix whose name CSPeach never puts in a command: one plain line, and it is passed over. */
+export const passedOverLine = (name) => `${objectShown(name)}: the name is not an ABAP name, so CSPeach passed it over.`;
+/** F16: the check a project measures with, said as a line. */
+export const checkedWithLine = (variant) => `  Checked with: ${variant}.`;
+/* ── commands the journey queues ────────────────────────────────────────── */
+export const OBJECT_TYPE = /^[A-Z]{4}$/;
+/** An ABAP object name: letters, digits, underscores, an optional /NAMESPACE/ in front. */
+export const OBJECT_NAME = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,40}$/;
+const LANE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
+export const MAX_REASON = 300;
+const chars = (...codes) => String.fromCharCode(...codes);
+/** Straight, back and curly quotes. */
+const QUOTES = new RegExp(`["'${chars(0x60, 0x2018, 0x2019, 0x201c, 0x201d)}]`, 'g');
+/** Bidi isolates and the Arabic letter mark (shown() already drops the other bidi and zero-width characters). */
+const ISOLATES = new RegExp(`[${chars(0x61c, 0x2066, 0x2067, 0x2068, 0x2069)}]`, 'g');
+/** Dashes and the minus: the command holds exactly one " — ", the one before the reason. */
+const DASHES = new RegExp(`[${chars(0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2212)}]`, 'g');
+/** A word that would be read as an image to attach (the turn attaches typed image paths). */
+const IMAGE_WORD = /\.(png|jpe?g|gif|webp)\b/gi;
+/**
+ * A recorded reason as the person wrote it, for a card: escape sequences,
+ * control, zero-width and bidi characters gone, at most `max` characters.
+ * Not the command text — that is cleanReason().
+ */
+export function shownReason(reason, max) {
+    return shownUpTo(String(reason ?? '').replace(ISOLATES, ''), max);
+}
+/**
+ * A reason as one plain line for the queued command: escape sequences,
+ * control, zero-width and bidi characters gone (shown()); no quotes; no
+ * dashes but a plain hyphen; and nothing the turn would act on — no `@`
+ * (a file to attach), no `--` (a flag such as --from), no `[ ]` (an image
+ * chip), no image file name. At most 300 characters.
+ */
+export function cleanReason(reason) {
+    return shownUpTo(String(reason ?? '').replace(ISOLATES, ''), Number.MAX_SAFE_INTEGER)
+        .replace(QUOTES, '')
+        .replace(DASHES, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/@/g, ' ')
+        .replace(/\[/g, '(')
+        .replace(/\]/g, ')')
+        .replace(IMAGE_WORD, ' $1')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, MAX_REASON)
+        .trim();
+}
+/** `/abap-clean-core triage lane <id>`, or null when the id is not one CSPeach passes on. */
+export function triageCommand(laneId) {
+    return LANE_ID.test(laneId) ? `/abap-clean-core triage lane ${laneId}` : null;
+}
+/** `/abap-refactor <TYPE> <NAME> — <reason>`, names upper-cased; null when a name is not an ABAP name. */
+export function refactorCommand(o) {
+    const type = o.type.trim().toUpperCase();
+    const name = o.name.trim().toUpperCase();
+    if (!OBJECT_TYPE.test(type) || !OBJECT_NAME.test(name))
+        return null;
+    const reason = cleanReason(o.reason);
+    return `/abap-refactor ${type} ${name}${reason ? ` — ${reason}` : ''}`;
+}
+/* ── the runner ─────────────────────────────────────────────────────────── */
+const result = (stage, lines, next, skip) => ({ stage, lines, next, ...(skip ? { skip } : {}) });
+/** A package name typed in full: no pattern, nothing that is not a package name. */
+const PACKAGE = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,30}$/;
+const IS_PATTERN = /[*?%]/;
+/**
+ * Run one stage. Never throws: anything unexpected comes back as one plain
+ * line and a stop. Headless runs nothing and queues nothing; it says the next step.
+ */
+export async function runJourneyStage(stage, ctx) {
+    try {
+        if (ctx.headless)
+            return nextStepOnly(stage, ctx);
+        // Said before any card: a step that needs SAP, in a session without one.
+        if (ctx.team.deps.noSap && (stage === 'INVENTORY' || stage === 'START' || stage === 'PROVE'))
+            return result(stage, [NO_SAP_LINE], { kind: 'stop' });
+        switch (stage) {
+            case 'UNREADABLE': return result(stage, [UNREADABLE_LINES[unreadableReason(facts(ctx)) ?? 'other']], { kind: 'stop' });
+            case 'INVENTORY': return await inventory(ctx);
+            case 'START': return await start(ctx);
+            case 'JOIN': return await joinStage(ctx);
+            case 'UNOWNED': return unowned(ctx);
+            case 'DECIDE': return decideStage(ctx);
+            case 'FIX': return fixStage(ctx);
+            case 'PROVE': return await prove(ctx);
+            case 'REPORT': return await report(ctx);
+            case 'DONE': return done(ctx);
+        }
+    }
+    catch (e) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        const said = [`✗ ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`];
+        return result(stage, [failure(said, 'This step could not finish.')], { kind: 'stop' });
+    }
+}
+const me = (ctx) => whoAmI(ctx.team.deps);
+const facts = (ctx) => readJourneyFacts(ctx.cwd, me(ctx), ctx.skips);
+/** Run a team body with its output kept back; `said` holds only this run's lines. */
+async function quiet(ctx, args) {
+    const { said } = ctx.team;
+    said.length = 0;
+    const code = await runTeamCommand(args, ctx.team.deps);
+    return { code, said: [...said] };
+}
+/** Headless / one-shot: the next step in words, nothing run, nothing queued. */
+function nextStepOnly(stage, ctx) {
+    const stop = (line) => result(stage, [line], { kind: 'stop' });
+    switch (stage) {
+        case 'UNREADABLE': return stop(UNREADABLE_LINES[unreadableReason(facts(ctx)) ?? 'other']);
+        case 'INVENTORY': return stop(`Next: ${step(stage, 'look at what custom code is on the system.')}`);
+        case 'START': {
+            const named = (ctx.packages ?? []).map((p) => p.trim().toUpperCase()).filter((p) => PACKAGE.test(p));
+            // F16: headless shows no card; the check it would start with is said as a line.
+            const objects = inventoryObjects(ctx.cwd, named);
+            return result(stage, [
+                `Next: ${step(stage, `start your project${named.length ? ` on ${named.join(', ')}` : ''} in this folder.`)}`,
+                checkedWithLine(DEFAULT_ATC_VARIANT),
+                // I15: above 500 objects the first check is per package, said as a line.
+                ...(objects !== null && objects > FIRST_CHECK_WHOLE_MAX ? [FIRST_CHECK_PER_PACKAGE_LINE] : []),
+            ], { kind: 'stop' });
+        }
+        case 'JOIN': return stop(`Next: ${step(stage, 'pick up the project in this folder.')}`);
+        case 'UNOWNED': return unowned(ctx);
+        case 'DECIDE':
+        case 'FIX': {
+            if (needsFirstCheck(facts(ctx)))
+                return nothingMeasuredResult(stage);
+            const r = stage === 'DECIDE' ? decideStage(ctx) : fixStage(ctx);
+            // Names passed over are still said; the step line gives way to the command.
+            return r.next.kind === 'queue'
+                ? result(stage, [...r.lines.filter((l) => !l.startsWith('Step ') && !l.startsWith('  ')), `Next: ${r.next.command}`], { kind: 'stop' }, r.skip)
+                : r;
+        }
+        case 'PROVE': return stop(`Next: ${step(stage, 'let SAP check your fixes.')}`);
+        case 'REPORT': return nothingMeasured(facts(ctx)) ? nothingMeasuredResult(stage) : stop(`Next: ${step(stage, 'make the status page.')}`);
+        case 'DONE': return done(ctx);
+    }
+}
+/* INVENTORY — what is out there. */
+async function inventory(ctx) {
+    const { code, said } = await quiet(ctx, ['discover', '--out', ctx.cwd]);
+    const found = code === 0 ? readEstate(ctx.cwd) : null;
+    const s = found ? estateSummaryOf(found.estate) : null;
+    if (!s)
+        return result('INVENTORY', [failure(said, 'The system could not be read.')], { kind: 'stop' });
+    const t = s.totals;
+    const words = [
+        `${plural(t.packages, 'package', 'packages')} with ${plural(t.codeObjects, 'code object', 'code objects')}.`,
+        ...(t.modifications ? [`${plural(t.modifications, 'change', 'changes')} to SAP's own objects.`] : []),
+        usageLineWithWindow(s),
+    ];
+    return result('INVENTORY', [`${step('INVENTORY', 'what is out there.')} ${words.join(' ')}`], { kind: 'continue' });
+}
+/* START — the project on the named packages, in this folder. */
+async function start(ctx) {
+    const stop = (line) => result('START', [line], { kind: 'stop' });
+    const asked = (ctx.packages ?? []).map((p) => p.trim().toUpperCase()).filter(Boolean);
+    if (!asked.length)
+        return stop('Which package first? Say: start clean core on ZFI_AR.');
+    if (asked.some((p) => IS_PATTERN.test(p)))
+        return stop('Name each package in full, for example ZFI_AR — not a pattern.');
+    if (asked.some((p) => !PACKAGE.test(p)))
+        return stop('Name each package in full, for example ZFI_AR.');
+    const packages = [...new Set(asked)];
+    // Checked against the system's own package list when the folder holds one.
+    const found = readEstate(ctx.cwd);
+    const known = found ? estateSummaryOf(found.estate)?.packages.map((p) => p.name.toUpperCase()) : undefined;
+    const unknown = known ? packages.filter((p) => !known.includes(p)) : [];
+    if (unknown.length)
+        return stop(`CSPeach did not find ${unknown.length === 1 ? 'the package' : 'the packages'} ${unknown.join(', ')} on the system.`);
+    const asWith = ctx.variant && VARIANT_NAME.test(ctx.variant) ? ['--atc-variant', ctx.variant] : [];
+    // I15: above 500 objects the start measures nothing; the chain offers the per-package first check.
+    const big = isBigStart(ctx.cwd, packages);
+    const { code, said } = await quiet(ctx, ['start', ...packages, '--folder', ctx.cwd, ...asWith, ...(big ? ['--no-measure'] : [])]);
+    if (code !== 0)
+        return stop(failure(said, 'The project could not be started.'));
+    let name = packages.join(', ');
+    let variant = asWith[1] ?? DEFAULT_ATC_VARIANT;
+    try {
+        const project = readProjectFile(ctx.cwd);
+        name = shown(project.name);
+        if (project.atcVariant && VARIANT_NAME.test(project.atcVariant))
+            variant = project.atcVariant;
+    }
+    catch { /* the name and the check it was started with */ }
+    const objects = said.map((l) => /^\s*([\d,]+) objects?, matched against/.exec(l)?.[1]).find(Boolean);
+    const check = said.map((l) => /First check \([^)]*\): ([\d,]+) of ([\d,]+) objects? with findings/.exec(l)).find(Boolean);
+    const lines = [`✓ Your project on ${name} started here.`, checkedWithLine(variant)];
+    if (objects)
+        lines.push(`  ${objects} ${objects === '1' ? 'object' : 'objects'}, matched against the system's count.`);
+    lines.push(check ? `  First check: ${check[1]} of ${check[2]} objects with findings.` : '  No check yet.');
+    // Review T7 finding 2: init decides "big" from the live pull, which may differ from the inventory.
+    const perPackage = !check && said.includes(FIRST_CHECK_PER_PACKAGE_LINE);
+    return { ...result('START', lines, { kind: 'continue' }), ...(perPackage ? { firstCheckPerPackage: true } : {}) };
+}
+/** Code objects the folder's inventory holds for these packages; null when it does not know them all. */
+function inventoryObjects(cwd, packages) {
+    const found = readEstate(cwd);
+    const s = found ? estateSummaryOf(found.estate) : null;
+    if (!s || !packages.length)
+        return null;
+    const by = new Map(s.packages.map((p) => [p.name.toUpperCase(), p.codeObjects]));
+    if (packages.some((p) => !by.has(p.toUpperCase())))
+        return null;
+    return packages.reduce((n, p) => n + (by.get(p.toUpperCase()) ?? 0), 0);
+}
+/** A start the 30-minute whole-baseline check would cut (I15): more than 500 objects, known from the inventory. */
+export function isBigStart(cwd, packages) {
+    const n = inventoryObjects(cwd, packages.map((p) => p.trim().toUpperCase()).filter(Boolean));
+    return n !== null && n > FIRST_CHECK_WHOLE_MAX;
+}
+/**
+ * The first check, one package at a time (I15): `team refresh --all
+ * --per-package`, which resumes where it stopped. Never throws.
+ */
+export async function firstCheckPerPackage(ctx) {
+    try {
+        const { code, said } = await quiet(ctx, ['refresh', '--all', '--per-package']);
+        const done = said.find((l) => /^✓ [\d,]+ packages? measured, one record each\./.test(l));
+        if (code === 0 && done)
+            return result('START', [`  First check: ${done.replace(/^✓ /, '')}`], { kind: 'continue' });
+        const stopped = said.find((l) => /^✗ (Stopped|Lost the connection)/.test(l));
+        return result('START', [stopped ? `  ${stopped.replace(/^✗ /, '')}` : failure(said, 'The first check could not finish.'), FIRST_CHECK_PER_PACKAGE_LINE], { kind: 'stop' });
+    }
+    catch (e) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        return result('START', ['The first check could not finish.', FIRST_CHECK_PER_PACKAGE_LINE], { kind: 'stop' });
+    }
+}
+/* JOIN — a project in this folder this laptop does not record into. */
+async function joinStage(ctx) {
+    const f = facts(ctx);
+    const folder = f.folder;
+    // Out of a synced file someone else may have written: cleaned before it is shown.
+    const lead = 'lead' in folder ? shown(folder.lead) : '';
+    const name = 'name' in folder ? shown(folder.name) : '';
+    if (folder.kind === 'unreadable')
+        return result('JOIN', [UNREADABLE_LINES[folder.reason]], { kind: 'stop' });
+    if (folder.kind !== 'mine-not-joined' && folder.kind !== 'someone-else')
+        return result('JOIN', [], { kind: 'continue' });
+    if (folder.kind === 'someone-else') {
+        const res = await ctx.team.confirm({
+            id: 'journey-join',
+            tag: 'QUESTION',
+            title: `This folder holds ${lead}'s project ${name}. Work in it?`,
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'yes', n: 'no' },
+        });
+        if (res.cancelled || res.value !== 'yes')
+            return result('JOIN', ['Nothing changed in this folder.'], { kind: 'stop' });
+    }
+    // Step 2 (spec §3.6, F13, cut 5): a lane owner who shares my first name is
+    // asked about once; two of them are never guessed between.
+    let asName;
+    if (folder.kind === 'someone-else') {
+        const match = ownerByFirstName(ctx.cwd, me(ctx));
+        if (match.kind === 'several') {
+            return result('JOIN', [severalLine(match)], { kind: 'stop' });
+        }
+        if (match.kind === 'one') {
+            const res = await ctx.team.confirm({
+                id: 'journey-join-name',
+                tag: 'QUESTION',
+                title: `Are you ${match.owner}?`,
+                facts: [match.lane],
+                choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+                initial: 0,
+                aliases: { y: 'yes', n: 'no' },
+            });
+            if (res.cancelled || res.value === null)
+                return result('JOIN', ['Nothing changed in this folder.'], { kind: 'stop' });
+            if (res.value === 'yes')
+                asName = match.owner;
+        }
+    }
+    // Results go straight into the folder.
+    const { code, said } = await quiet(ctx, ['join', ctx.cwd, '--outbox', ctx.cwd, ...(asName ? ['--as', asName] : [])]);
+    if (code !== 0)
+        return result('JOIN', [failure(said, 'The project in this folder could not be opened.')], { kind: 'stop' });
+    const line = folder.kind === 'mine-not-joined'
+        ? `Picking up your project on ${name}.`
+        : `✓ Working in ${lead}'s project ${name}${asName ? ` as ${asName}` : ''}.`;
+    return result('JOIN', [line], { kind: 'continue' });
+}
+/**
+ * The lane owner I may be, decided by team.ts `ownerMatch` (the one shared
+ * rule), with that person's lanes' size for the card.
+ */
+function ownerByFirstName(cwd, myName) {
+    let lanes = [];
+    try {
+        lanes = readLanes(cwd);
+    }
+    catch {
+        return { kind: 'none' };
+    }
+    const m = ownerMatch(lanes, myName);
+    if (m.kind === 'several')
+        return m;
+    if (m.kind !== 'one')
+        return { kind: 'none' };
+    const ids = new Set(m.laneIds);
+    const packages = new Set(lanes.filter((l) => ids.has(l.id)).flatMap((l) => l.packages)).size;
+    let objects = null;
+    try {
+        objects = registerFor(cwd).register.lanes.filter((l) => ids.has(l.id)).reduce((n, l) => n + l.objects, 0);
+    }
+    catch {
+        objects = null;
+    }
+    const size = `${plural(packages, 'package', 'packages')}${objects === null ? '' : `, ${plural(objects, 'object', 'objects')}`}`;
+    return { kind: 'one', owner: m.owner, lane: `Your lane: ${size}.` };
+}
+/* UNOWNED — joined, and nothing here is mine yet (spec §3.6). Never DONE. */
+function unowned(ctx) {
+    let lead = '';
+    try {
+        lead = readProjectFile(ctx.cwd).lead.name;
+    }
+    catch { /* the line without a name */ }
+    return result('UNOWNED', [`You own nothing here yet. Ask ${lead ? shown(lead) : 'the lead'} to move packages to you.`], { kind: 'stop' });
+}
+/* DECIDE — the triage of my objects, a model step. */
+function decideStage(ctx) {
+    const f = facts(ctx);
+    const left = f.register ? toDecide(f.register, f.me, f.skip) : [];
+    const lane = left[0]?.lane;
+    const command = lane ? triageCommand(lane) : null;
+    if (!command)
+        return result('DECIDE', ['Nothing to decide that CSPeach can hand on.'], { kind: 'stop' });
+    return result('DECIDE', [`${step('DECIDE', 'decide what happens to each object.')} ${plural(left.length, 'object', 'objects')} to go.`], { kind: 'queue', command });
+}
+/* FIX — the next object to fix, a model step. */
+function fixStage(ctx) {
+    const f = facts(ctx);
+    const left = f.register ? toFix(f.register, f.me, f.skip) : [];
+    // A name that is not an ABAP name is passed over with one line; the next one is queued.
+    const passed = [];
+    for (const o of left) {
+        // The reason comes from the recorded decision only, never from the model's words.
+        const command = refactorCommand({ type: o.type, name: o.name, ...(o.decision?.reason ? { reason: o.decision.reason } : {}) });
+        if (!command) {
+            passed.push(o);
+            continue;
+        }
+        const lines = [...passed.map((x) => passedOverLine(x.name)), `${step('FIX', `fix ${o.name.toUpperCase()}.`)}`];
+        if (fixFailedCheck(o))
+            lines.push('  Its last fix failed the check.');
+        return result('FIX', lines, { kind: 'queue', command, key: o.key }, passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
+    }
+    return result('FIX', passed.map((x) => passedOverLine(x.name)), { kind: 'continue' }, passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
+}
+/** What a check of my claimed fixes measures: my one area, or the packages of the claimed objects. */
+function proveScope(f, waiting) {
+    const r = f.register;
+    const joined = activeProject();
+    const lanes = joined ? readLanes(joined.projectDir).filter((l) => l.owner.trim().toLowerCase() === f.me.trim().toLowerCase()) : [];
+    if (lanes.length === 1)
+        return { args: ['refresh'], objects: myObjects(r, f.me).length };
+    const packages = [...new Set(waiting.map((o) => o.package))];
+    return {
+        args: ['refresh', '--packages', packages.join(',')],
+        objects: r.objects.filter((o) => o.inScope && packages.includes(o.package)).length,
+    };
+}
+/**
+ * What a check that ran says about one object's fix. A fix the check says did
+ * not hold, with nothing open for its own target, is proven FOR THAT TARGET
+ * (spec §3.2, proof first) — "would only matter for A" only when every finding
+ * left is one that only level A cares about.
+ */
+export function proveLine(name, now) {
+    if (now.state === 'verified')
+        return `${name}: fix proven.`;
+    // F12: an object clean at its check never had a fix to prove.
+    if (now.state === 'clean')
+        return `${name}: no findings.`;
+    if (provenForTarget(now))
+        return `${name}: ${provenForTargetWords(now)}.`;
+    if (fixFailedCheck(now) && !claimedSinceCheck(now))
+        return `${name}: fix failed the check.`;
+    return `${name}: not checked yet.`;
+}
+/* PROVE — SAP checks the claimed fixes. */
+async function prove(ctx) {
+    const f = facts(ctx);
+    if (!f.register)
+        return result('PROVE', [UNREADABLE_LINES[unreadableReason(f) ?? 'other']], { kind: 'stop' });
+    const waiting = toProve(f.register, f.me);
+    if (!waiting.length)
+        return result('PROVE', [], { kind: 'continue' });
+    const scope = proveScope(f, waiting);
+    const res = await ctx.team.confirm({
+        id: 'journey-prove',
+        tag: 'QUESTION',
+        title: `Let SAP check your ${plural(scope.objects, 'object', 'objects')}? ${minutes(scope.objects)}`,
+        facts: ['Reads only. Nothing in SAP is changed.'],
+        choices: [{ value: 'yes', label: 'Yes' }, { value: 'later', label: 'Later' }],
+        initial: 0,
+        aliases: { y: 'yes', l: 'later' },
+    });
+    if (res.value === 'later' && !res.cancelled)
+        return result('PROVE', ['Left for later.'], { kind: 'continue' }, { prove: true });
+    if (res.cancelled || res.value !== 'yes')
+        return result('PROVE', ['Not checked.'], { kind: 'stop' });
+    const { said } = await quiet(ctx, scope.args);
+    const measured = said.map((l) => /^✓ ([\d,]+) objects? measured/.exec(l)?.[1]).find(Boolean);
+    const after = readJourneyFacts(ctx.cwd, f.me, ctx.skips).register;
+    const byKey = new Map((after?.objects ?? []).map((o) => [o.key, o]));
+    const lines = [];
+    for (const was of waiting) {
+        const now = byKey.get(was.key);
+        const name = objectShown(was.name);
+        if (!now || !now.lastMeasuredAt || now.lastMeasuredAt === was.lastMeasuredAt)
+            lines.push(`${name}: not checked yet.`);
+        else
+            lines.push(proveLine(name, now));
+    }
+    if (!measured && lines.every((l) => l.endsWith('not checked yet.'))) {
+        return result('PROVE', [failure(said, 'SAP could not check them right now.')], { kind: 'stop' });
+    }
+    return result('PROVE', [`✓ ${measured ?? waiting.length} checked.`, ...lines], { kind: 'continue' });
+}
+/* REPORT — the status page and the workbook, in reports/. */
+async function report(ctx) {
+    // A status page with nothing measured on it is no report (review T7 finding 1).
+    if (nothingMeasured(facts(ctx)))
+        return nothingMeasuredResult('REPORT');
+    const joined = activeProject();
+    if (!joined)
+        return result('REPORT', [UNREADABLE_LINES.other], { kind: 'stop' });
+    const project = readProjectFile(joined.projectDir);
+    const mine = project.lead.name.trim().toLowerCase() === me(ctx).trim().toLowerCase();
+    // The status page of a shared folder is its lead's to make.
+    if (!mine)
+        return result('REPORT', [`The status page is made by ${shown(project.lead.name)}.`], { kind: 'continue' }, { report: true });
+    const { saved, held } = writeReports(joined.projectDir, project, path.join(joined.projectDir, 'reports'), ctx.team.deps);
+    const lines = [];
+    if (saved.length)
+        lines.push(`✓ Saved ${saved.map((n) => `"${n}"`).join(' and ')} in the reports folder.`);
+    for (const name of held)
+        lines.push(`  "${name}" is open in another program, so it was not updated. Close it and say carry on.`);
+    const page = saved.find((n) => n.toLowerCase().endsWith('.html'));
+    if (page) {
+        const res = await ctx.team.confirm({
+            id: 'journey-open-report',
+            tag: 'QUESTION',
+            title: 'Open the status page in your browser?',
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'yes', n: 'no' },
+        });
+        if (res.value === 'yes' && !res.cancelled) {
+            try {
+                const said = await ctx.openFile?.(path.join(joined.projectDir, 'reports', page));
+                if (Array.isArray(said))
+                    lines.push(...said);
+            }
+            catch {
+                lines.push('  Could not open the browser — open the page from the reports folder.');
+            }
+        }
+    }
+    // The report is saved whatever happens to the CSV files: a failure here is one line, never the stage.
+    try {
+        lines.push(...await csvExport(ctx, joined.projectDir, project));
+    }
+    catch (e) {
+        const said = e instanceof Error ? e.message : String(e);
+        lines.push(`  The CSV files could not be written: ${failureLine([`✗ ${said.split('\n')[0]}`], 'the folder could not be written to').replace(/[\s.…]+$/, '')}.`);
+    }
+    return result('REPORT', lines, { kind: 'continue' }, { report: true });
+}
+const CSV_SAVED = '✓ Saved the CSV files for your own tools in the exports folder.';
+/**
+ * The CSV export at REPORT (spec §3.4, D2): written when the project file's
+ * switch is on; otherwise one card. "Every time" turns the switch on (visible
+ * in the project file), "Just this once" writes them, "No" or a card put away
+ * writes nothing. A headless chain never reaches REPORT (it stops at the
+ * next-step line before it), so there is no card and no file there.
+ */
+async function csvExport(ctx, projectDir, project) {
+    const write = () => {
+        const { saved, held } = writeExports(projectDir, project, path.join(projectDir, 'reports', EXPORTS_DIR), ctx.team.deps);
+        return [
+            ...(saved.length ? [CSV_SAVED] : []),
+            ...held.map((name) => `  "${name}" is open in another program, so it was not updated. Close it and say carry on.`),
+        ];
+    };
+    if (exportsOn(project))
+        return write();
+    const res = await ctx.team.confirm({
+        id: 'journey-export',
+        tag: 'QUESTION',
+        title: 'Also write CSV files for your own tools?',
+        choices: [{ value: 'every', label: 'Every time' }, { value: 'once', label: 'Just this once' }, { value: 'no', label: 'No' }],
+        initial: 2,
+        aliases: { e: 'every', j: 'once', n: 'no' },
+    });
+    if (res.cancelled || (res.value !== 'every' && res.value !== 'once'))
+        return [];
+    if (res.value === 'once')
+        return write();
+    setExportsAlways(projectDir);
+    return [...write(), '  They are written with every report from now on.'];
+}
+/** The closing count of objects kept: "1 kept as is", "2 kept as they are". */
+export const keptPart = (n) => `${n} ${n === 1 ? 'kept as is' : 'kept as they are'}`;
+/* DONE — a short summary. */
+/** Said instead of "Done for now." when the project has no counted check at all. */
+export const NOTHING_MEASURED_LINE = 'Nothing is measured yet.';
+/** The folder's project has no counted check run (I15, review T7 finding 1). */
+export function nothingMeasured(f) {
+    return !!f.register && f.register.runs.length === 0;
+}
+/** Nothing measured, and too many objects for one check: the per-package first check comes first (I15). */
+export function needsFirstCheck(f) {
+    return nothingMeasured(f) && f.register.objects.length > FIRST_CHECK_WHOLE_MAX;
+}
+const nothingMeasuredResult = (stage) => result(stage, [NOTHING_MEASURED_LINE, FIRST_CHECK_PER_PACKAGE_LINE], { kind: 'stop' });
+function done(ctx) {
+    const f = facts(ctx);
+    // Never "Done for now." with nothing measured.
+    if (nothingMeasured(f))
+        return nothingMeasuredResult('DONE');
+    const lines = ['Done for now.'];
+    if (f.register) {
+        const mine = myObjects(f.register, f.me);
+        const count = (pred) => mine.filter(pred).length;
+        const parts = [
+            [count((o) => o.state === 'clean'), 'clean'],
+            [count((o) => o.state === 'verified'), 'fix proven'],
+        ].filter(([n]) => n > 0).map(([n, w]) => `${n} ${w}`);
+        const kept = count((o) => o.decision?.classification === 'keep' && o.state !== 'clean');
+        if (kept)
+            parts.push(keptPart(kept));
+        if (mine.length)
+            lines.push(`  ${plural(mine.length, 'object', 'objects')}${parts.length ? `: ${parts.join(', ')}` : ''}.`);
+        const rebuild = toRedesign(f.register, f.me).length;
+        if (rebuild)
+            lines.push(`  ${plural(rebuild, 'object', 'objects')} planned for a rebuild — handled separately.`);
+    }
+    lines.push('Next time, open CSPeach in this folder and say carry on.');
+    return result('DONE', lines, { kind: 'done' });
+}