@cspeach/cli 1.1.50 → 1.1.52

package/dist/commands/export-conversation.js

@@ -0,0 +1,346 @@
+// cspeach-cli/src/commands/export-conversation.ts
+//
+// /export docx (2026-10-23, from a customer's own words): turn what he sees in
+// the terminal into a Word document at any point, to attach to the change
+// ticket.
+//
+//   /export docx               the last answer CSPeach gave
+//   /export docx conversation  the whole conversation so far: the developer's
+//                              messages, CSPeach's answers, and every question
+//                              CSPeach asked (ask_question, approvals) with the
+//                              options shown and the answer picked
+//   /export docx <file>.md     unchanged (export-docx.ts)
+//
+// Reads only what is already in the session: no model call, no SAP call.
+// Raw tool results are never written (a source body read from SAP stays out);
+// only the answers to questions are taken from them. Files go to
+// cspeach-out/ (never overwritten), the .docx next to the .md.
+import fs from 'node:fs';
+import path from 'node:path';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { writeDocxNextTo, writeNoClobber } from '../docx/write-docx.js';
+import { normalizeAskInput } from '../tools/ask-question.js';
+import { INJECTED_CONTEXT_TAGS, isUserPrompt, userPromptText } from '../session/user-prompt.js';
+import { resolveCliMarks, startsTurn } from '../session/cli-record.js';
+import { docxFileFromReplArgs, runExportDocxCommand } from './export-docx.js';
+// The usage line lives in the light export-audit module (final-review I-2); re-exported here.
+export { EXPORT_REPL_USAGE } from './export-audit.js';
+const OUT_DIR = 'cspeach-out';
+/** HTML comments are machine blocks (artefact manifests, widget markers): the terminal never shows them. */
+function readerText(text) {
+    return text.replace(/<!--[\s\S]*?-->/g, '').replace(/\n{3,}/g, '\n\n').trim();
+}
+/**
+ * Context blocks the CLI adds to a prompt (the developer never typed them) are
+ * dropped with the shared INJECTED_CONTEXT_TAGS list (session/user-prompt.ts),
+ * which carries Stage 1A's inline `<skill>` playbook blocks too.
+ */
+function typedText(text) {
+    let out = text;
+    for (const tag of INJECTED_CONTEXT_TAGS) {
+        out = out.replace(new RegExp(`<${tag}(?:\\s[^>]*)?>[\\s\\S]*?</${tag}>`, 'g'), '');
+    }
+    out = out.replace(/<attached file="([^"]*)">[\s\S]*?<\/attached>/g, (_m, f) => `@${f}`);
+    return out.trim();
+}
+function blocks(m) {
+    return Array.isArray(m.content) ? m.content : [];
+}
+function assistantTexts(m) {
+    if (m.role !== 'assistant')
+        return [];
+    if (typeof m.content === 'string')
+        return [m.content];
+    return blocks(m).filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text);
+}
+/** Indexes of the messages that start a turn: a typed prompt, a plan step, a queued step (fix round 1, I-1/I-2). */
+function turnStarts(messages, session) {
+    const out = [];
+    const marks = resolveCliMarks(session, messages);
+    messages.forEach((m, i) => { if (isUserPrompt(m) && startsTurn(marks[i]))
+        out.push(i); });
+    return out;
+}
+/**
+ * The last answer: everything CSPeach said after the last turn's prompt. A
+ * continuation after the output limit, a watchdog note or a mid-turn steer is
+ * not a new turn, so a long answer comes out whole. `turn` = session.turn_seq
+ * when the session has it (right after a compaction too), else the count.
+ */
+export function lastAnswer(messages, session) {
+    const starts = turnStarts(messages, session);
+    if (starts.length === 0)
+        return null;
+    const last = starts[starts.length - 1];
+    const turn = session?.turn_seq ?? starts.length;
+    const text = readerText(messages.slice(last + 1).flatMap(assistantTexts).join('\n\n'));
+    return text.length > 0 ? { text: text + '\n', turn } : null;
+}
+/** tool_use_id → the result's text (only read for questions and approvals). */
+function resultsById(messages) {
+    const out = new Map();
+    for (const m of messages) {
+        if (m.role !== 'user')
+            continue;
+        for (const b of blocks(m)) {
+            if (b?.type !== 'tool_result' || typeof b.tool_use_id !== 'string')
+                continue;
+            const c = b.content;
+            const text = typeof c === 'string' ? c
+                : Array.isArray(c) ? c.filter((x) => x?.type === 'text').map((x) => String(x.text ?? '')).join('') : '';
+            out.set(b.tool_use_id, text);
+        }
+    }
+    return out;
+}
+function parse(json) {
+    if (json === undefined)
+        return undefined;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+const quote = (lines) => lines.map((l) => (l.length ? `> ${l}` : '>')).join('\n');
+/** One question (or a form of up to four) with its options and the answer picked. */
+function questionBlock(input, result) {
+    let form;
+    try {
+        form = normalizeAskInput(input);
+    }
+    catch {
+        return null;
+    }
+    const r = parse(result);
+    const answers = [];
+    if (r && Array.isArray(r.answers)) {
+        for (const a of r.answers)
+            answers.push({ id: String(a?.id), answer: a?.answer == null ? null : String(a.answer), auto: a?.auto_answered === true });
+    }
+    else if (r && 'answer' in r) {
+        answers.push({ id: String(r.id ?? form.questions[0]?.id), answer: r.answer == null ? null : String(r.answer), auto: r.auto_answered === true });
+    }
+    const out = [];
+    for (const q of form.questions) {
+        out.push(`**CSPeach asked:** ${q.question}`);
+        if (q.options.length)
+            out.push(`Options: ${q.options.map((o) => o.label).join(' · ')}`);
+        const a = answers.find((x) => x.id === q.id) ?? (form.questions.length === 1 ? answers[0] : undefined);
+        if (a && a.answer !== null && a.answer.length > 0) {
+            const shown = q.options.length && !q.freeText
+                ? a.answer.split(',').map((v) => q.options.find((o) => o.value === v)?.label ?? v).join(', ')
+                : a.answer;
+            out.push(a.auto ? `**Answer (picked automatically, no one answered):** ${shown}` : `**Answer:** ${shown}`);
+        }
+        else if (r?.error === 'headless_unanswerable' || r?.error === undefined && r?.headless) {
+            out.push('**Answer:** none (no one was there to answer)');
+        }
+        else if (r?.cancelled) {
+            out.push('**Answer:** none (the question was closed)');
+        }
+        else {
+            out.push('**Answer:** not recorded');
+        }
+        out.push('');
+    }
+    return quote(out.slice(0, -1));
+}
+/** An approval CSPeach asked for: the summary, the changes (never the diff), the answer. */
+function approvalBlock(input, result) {
+    const r = parse(result);
+    if (!r || r.error)
+        return null; // refused before anything was shown: no question was asked
+    const out = [`**CSPeach asked for approval:** ${String(input?.summary ?? 'a change')}`];
+    for (const c of Array.isArray(input?.changes) ? input.changes : []) {
+        out.push(`- ${String(c?.op ?? '')} ${String(c?.object ?? '')}${c?.type ? ` (${String(c.type)})` : ''}`.replace(/\s+/g, ' ').trimEnd());
+    }
+    let answer;
+    if (typeof r.advisory_outcome === 'string') {
+        answer = r.headless ? '**Answer (no one answered):** not applied'
+            : `**Answer:** ${r.advisory_outcome === 'applied' ? 'applied by hand' : r.advisory_outcome === 'aborted' ? 'stopped' : 'skipped'}`;
+    }
+    else if (r.auto_approved) {
+        answer = '**Answer (approved automatically, auto-approve is on):** Approved';
+    }
+    else if (typeof r.approved_by === 'string') {
+        answer = `**Answer (approved earlier, by ${r.approved_by}):** Approved`;
+    }
+    else if (r.reason === 'headless_no_approval') {
+        answer = '**Answer (no one answered):** Not approved';
+    }
+    else if (r.reason === 'plan_rejected') {
+        answer = '**Answer:** Cancelled at the plan gate';
+    }
+    else if (r.reason === 'user_cancelled_turn') {
+        answer = '**Answer:** Stopped';
+    }
+    else if (r.approved === true) {
+        const skipped = Array.isArray(r.skipped) ? r.skipped.map((s) => String(s?.object ?? '')).filter(Boolean) : [];
+        answer = skipped.length ? `**Answer:** Approved, except ${skipped.join(', ')} (skipped)` : '**Answer:** Approved';
+    }
+    else {
+        answer = '**Answer:** Not approved';
+    }
+    out.push(answer);
+    return quote(out);
+}
+/** One CLI card: the question, what it showed, the options and the answer. */
+function cardBlock(c) {
+    const out = [`**CSPeach asked:** ${c.question}`];
+    // Fix round 2 (N-1): when it was answered (UTC, to the minute) and which plan it was about.
+    const when = c.at && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(c.at) ? `At: ${c.at.slice(0, 10)} ${c.at.slice(11, 16)} UTC` : '';
+    const about = c.ref ? `Plan: ${c.ref}` : '';
+    if (when || about)
+        out.push([when, about].filter(Boolean).join(' · '));
+    for (const f of c.facts ?? [])
+        out.push(`- ${f}`);
+    if (c.options?.length)
+        out.push(`Options: ${c.options.join(' · ')}`);
+    out.push(c.by === 'user' ? `**Answer:** ${c.answer}`
+        : c.by === 'auto' ? `**Answer (picked automatically):** ${c.answer}`
+            : `**Answer (no one at the terminal):** ${c.answer}`);
+    return quote(out);
+}
+/** The whole conversation, in order. Pure: the same session always gives the same text. */
+export function conversationMarkdown(o) {
+    const results = resultsById(o.messages);
+    const parts = [
+        '# CSPeach conversation', '',
+        `- Date: ${o.date}`,
+        `- SAP system: ${o.system ? o.system : 'none'}`,
+        `- Session: ${o.sessionId}`,
+        ...(o.person ? [`- Signed in as: ${o.person}`] : []),
+    ];
+    let speaker = null;
+    const say = (who, text) => {
+        if (speaker !== who) {
+            parts.push('', who === 'you' ? '## You' : '## CSPeach');
+            speaker = who;
+        }
+        parts.push('', text);
+    };
+    // CLI cards, anchored by turn_seq. The turns kept in `messages` are the last
+    // ones, so the i-th turn start here is turn (turn_seq - count + 1 + i). A
+    // card answered in turn t is placed before the prompt of turn t + 1.
+    const cards = [...(o.session?.cli_cards ?? [])].sort((a, b) => a.turn_seq - b.turn_seq);
+    const starts = turnStarts(o.messages, o.session);
+    const marks = resolveCliMarks(o.session, o.messages);
+    const lastTurn = o.session?.turn_seq ?? starts.length;
+    const turnOf = new Map(starts.map((idx, i) => [idx, lastTurn - starts.length + 1 + i]));
+    let nextCard = 0;
+    const flushCards = (beforeTurn) => {
+        while (nextCard < cards.length && cards[nextCard].turn_seq < beforeTurn)
+            say('cspeach', cardBlock(cards[nextCard++]));
+    };
+    for (const [idx, m] of o.messages.entries()) {
+        if (m.role === 'user') {
+            const n = turnOf.get(idx);
+            if (n !== undefined)
+                flushCards(n);
+            const typed = userPromptText(m);
+            if (typed === null)
+                continue;
+            // A message CSPeach wrote itself: one plain line, never its body.
+            const mark = marks[idx];
+            if (mark && mark.kind !== 'steer') {
+                say('cspeach', `*${mark.line}*`);
+                continue;
+            }
+            const t = readerText(typedText(typed));
+            if (t.length)
+                say('you', t);
+            continue;
+        }
+        if (m.role !== 'assistant')
+            continue;
+        const list = typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : blocks(m);
+        for (const b of list) {
+            if (b?.type === 'text' && typeof b.text === 'string') {
+                const t = readerText(b.text);
+                if (t.length)
+                    say('cspeach', t);
+            }
+            else if (b?.type === 'tool_use' && typeof b.id === 'string') {
+                const block = b.name === 'ask_question' ? questionBlock(b.input, results.get(b.id))
+                    : b.name === 'request_approval' ? approvalBlock(b.input, results.get(b.id))
+                        : null;
+                if (block)
+                    say('cspeach', block);
+            }
+        }
+    }
+    flushCards(Number.POSITIVE_INFINITY);
+    return parts.join('\n') + '\n';
+}
+function localDate() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+async function saveWithCopy(target, markdown, meta, emit) {
+    let mdPath;
+    try {
+        await fs.promises.mkdir(path.dirname(target), { recursive: true });
+        mdPath = await writeNoClobber(target, markdown);
+    }
+    catch (e) {
+        emit(`Not saved. ${e.message}`);
+        return 1;
+    }
+    emit(`Saved: ${path.resolve(mdPath)}`);
+    try {
+        const docx = await writeDocxNextTo(mdPath, markdown, meta);
+        emit(`Word copy: ${path.resolve(docx)}`);
+        return 0;
+    }
+    catch (e) {
+        emit(`Word copy not written. ${e.message}`);
+        return 1;
+    }
+}
+/** `/export docx …` in the REPL (Ink and classic call this one body). */
+export async function runExportDocxRepl(o) {
+    const file = docxFileFromReplArgs(o.args);
+    const system = o.session.sap_system ?? null;
+    const cwd = o.cwd ?? process.cwd();
+    if (file !== undefined && /\.md$/i.test(file) && fs.existsSync(path.resolve(cwd, file))) {
+        // Unchanged: a Word copy next to an existing Markdown file.
+        return runExportDocxCommand({ file, docx: true, system, ...(o.cwd ? { cwd: o.cwd } : {}), ...(o.today ? { today: o.today } : {}), emit: o.emit });
+    }
+    const today = o.today ?? localDate();
+    const out = path.join(cwd, OUT_DIR);
+    if (file === undefined || !/^conversation$/i.test(file)) {
+        // The last answer. Any other name ("explain1", "explain1.docx", a .md that
+        // does not exist yet) is the name to save it under: bare names go to
+        // cspeach-out/, a name with a folder goes where it says.
+        const a = lastAnswer(o.session.messages, o.session);
+        if (!a) {
+            o.emit('There is no answer to export yet.');
+            return 1;
+        }
+        const meta = metaFromMarkdown(a.text, { date: today, kind: 'answer', ...(system ? { system } : {}) });
+        const raw = (file ?? '').replace(/\.(?:md|docx)$/i, '').trim().replace(/\\/g, '/');
+        const folder = raw.slice(0, raw.lastIndexOf('/') + 1);
+        const name = raw.slice(folder.length).trim() || `${today}-answer-${a.turn}`;
+        // A colon after the drive letter would write into a hidden Windows file
+        // stream (the user sees an empty file); the others are never valid.
+        if (/[<>:"|?*]/.test(folder.replace(/^[A-Za-z]:\//, '') + name)) {
+            o.emit(`"${file}" cannot be a file name. Use letters, numbers, spaces, - or _, for example: /export docx explain1`);
+            return 1;
+        }
+        const target = folder ? path.resolve(cwd, folder, `${name}.md`) : path.join(out, `${name}.md`);
+        return saveWithCopy(target, a.text, meta, o.emit);
+    }
+    if (turnStarts(o.session.messages, o.session).length === 0) {
+        o.emit('There is no conversation to export yet.');
+        return 1;
+    }
+    const md = conversationMarkdown({ messages: o.session.messages, session: o.session, date: today, system, sessionId: o.session.id, ...(o.person ? { person: o.person } : {}) });
+    const meta = {
+        title: 'CSPeach conversation', date: today, kind: 'conversation', session: o.session.id,
+        ...(system ? { system } : {}), ...(o.person ? { person: o.person } : {}),
+    };
+    const short = o.session.id.replace(/[^A-Za-z0-9]/g, '').slice(0, 8) || 'session';
+    return saveWithCopy(path.join(out, `${today}-conversation-${short}.md`), md, meta, o.emit);
+}

package/dist/commands/finish-check-guard.js

@@ -0,0 +1,124 @@
+// cspeach-cli/src/commands/finish-check-guard.ts
+//
+// Finish-check guard (2026-10-23, inline-waiver findings §6 Option A).
+// A plan step may not be saved "validated" while that turn's LAST
+// rap_finish_check said fewer than 5 of 5 passed. The write-back
+// downgrades it to "blocked" (never refuses: a refusal would cost another
+// model turn). "validated-with-waiver" is kept only when the step's notes
+// name every failed item id.
+//
+// The guard acts only when it reads the check confidently. No check this
+// turn, an unreadable last check, a 5 of 5, or any other status → null
+// (today's behaviour).
+const TOOL_NAME = 'rap_finish_check';
+// The real handler's shape (tools/rap/finish-check.ts formatFinish):
+//   Finish check: <n> of 5 passed
+//   F<k> <title> — passed | needs work: <problems>
+const HEADER_RE = /^Finish check: (\d+) of (\d+) passed$/;
+const ITEM_RE = /^(F[1-5]) .*? — (passed|needs work:.*)$/;
+const ITEM_IDS = ['F1', 'F2', 'F3', 'F4', 'F5'];
+function resultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const b of content) {
+        if (b?.type === 'text' && typeof b.text === 'string')
+            parts.push(b.text);
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+/** The text of this turn's LAST rap_finish_check tool result, or null when there is none. */
+export function lastFinishCheckText(messages, messagesStart) {
+    const checkIds = new Set();
+    let last = null;
+    for (let i = Math.max(0, messagesStart); i < messages.length; i++) {
+        const m = messages[i];
+        if (!Array.isArray(m.content))
+            continue;
+        for (const b of m.content) {
+            if (!b || typeof b !== 'object')
+                continue;
+            if (m.role === 'assistant' && b.type === 'tool_use' && b.name === TOOL_NAME && typeof b.id === 'string') {
+                checkIds.add(b.id);
+            }
+            else if (m.role === 'user' && b.type === 'tool_result' && typeof b.tool_use_id === 'string' && checkIds.has(b.tool_use_id)) {
+                // An unreadable last result still counts as the last one: it makes the guard stand down.
+                last = resultText(b.content) ?? '';
+            }
+        }
+    }
+    return last;
+}
+/** Parses a rap_finish_check result; null unless every line agrees with the handler's shape. */
+export function parseFinishCheck(text) {
+    const lines = text.split(/\r?\n/).map((l) => l.trimEnd());
+    const head = HEADER_RE.exec(lines[0] ?? '');
+    if (!head)
+        return null;
+    const passed = Number(head[1]);
+    const total = Number(head[2]);
+    if (total !== ITEM_IDS.length || passed > total)
+        return null;
+    const seen = [];
+    const failed = [];
+    for (const line of lines.slice(1)) {
+        const m = ITEM_RE.exec(line);
+        if (!m)
+            continue;
+        seen.push(m[1]);
+        if (m[2] !== 'passed')
+            failed.push(m[1]);
+    }
+    if (seen.join(',') !== ITEM_IDS.join(','))
+        return null;
+    if (failed.length !== total - passed)
+        return null;
+    return { passed, total, failed };
+}
+const namesId = (notes, id) => new RegExp(`\\b${id}\\b`).test(notes);
+/**
+ * The guard's note: one place for its wording. It goes into the step's
+ * work.notes and is shown as the run line.
+ *   <step>: finish check 3 of 5, F1, F4 failed. Saved as blocked.
+ *   <step>: finish check 3 of 5, F1, F4 failed. The notes do not waive F4. Saved as blocked.
+ */
+const GUARD_NOTE_TAIL = 'Saved as blocked.';
+const GUARD_NOTE_HEAD = 'finish check';
+const GUARD_NOTE_RE = new RegExp(`: ${GUARD_NOTE_HEAD} \\d+ of \\d+, .* ${GUARD_NOTE_TAIL.replace(/\./g, '\\.')}$`);
+export function formatFinishGuardNote(a) {
+    const waiver = a.notWaived && a.notWaived.length > 0 ? ` The notes do not waive ${a.notWaived.join(', ')}.` : '';
+    return `${a.step}: ${GUARD_NOTE_HEAD} ${a.score.passed} of ${a.score.total}, ${a.score.failed.join(', ')} failed.${waiver} ${GUARD_NOTE_TAIL}`;
+}
+/** True for a line the guard wrote itself (it never counts as a waiver). */
+export function isFinishGuardNoteLine(line) {
+    return GUARD_NOTE_RE.test(line.trim());
+}
+/** The notes without the guard's own lines: only what the model or developer wrote. */
+function notesWithoutGuardLines(notes) {
+    return notes.split(/\r?\n/).filter((l) => !isFinishGuardNoteLine(l)).join('\n');
+}
+/**
+ * The guard's ruling for the executed step: `{ status: 'blocked', note }` when
+ * the claimed status must be downgraded, otherwise null (save as written).
+ * A waiver counts from any turn's notes, but never from the guard's own lines.
+ */
+export function finishCheckGuard(args) {
+    if (args.status !== 'validated' && args.status !== 'validated-with-waiver')
+        return null;
+    const text = lastFinishCheckText(args.messages, args.messagesStart);
+    if (text === null)
+        return null;
+    const score = parseFinishCheck(text);
+    if (!score || score.failed.length === 0)
+        return null;
+    let notWaived;
+    if (args.status === 'validated-with-waiver') {
+        const notes = notesWithoutGuardLines(args.notes ?? '');
+        notWaived = score.failed.filter((id) => !namesId(notes, id));
+        if (notWaived.length === 0)
+            return null;
+    }
+    return { status: 'blocked', note: formatFinishGuardNote({ step: args.step, score, notWaived }) };
+}

package/dist/commands/help.js

@@ -47,6 +47,9 @@ export const HELP_GROUPS = [
             { name: '/files', description: fixed('Pick a saved project file and what to do with it') },
             { name: '@<file>', description: fixed('Attach a file from this folder to your prompt') },
             { name: '/export audit [file]', description: fixed('Write the signable session audit record to a file') },
+            { name: '/export docx', description: fixed('Word copy of the last answer, saved in cspeach-out. Add a name to choose the file name: /export docx explain1') },
+            { name: '/export docx conversation', description: fixed('Word copy of the whole conversation: your messages, the answers, the questions and what you picked') },
+            { name: '/export docx <file>.md', description: fixed('Word copy of a Markdown file, next to it') },
         ] },
     { title: 'Session', rows: [
             { name: '/new', description: fixed('Next prompt picks a skill afresh (also /reset)') },

package/dist/commands/plan-boundary.js

@@ -1,4 +1,5 @@
 import { saveSession } from '../session/store.js';
+import { rebuildCliMarksAfterCompact, PLAN_BOUNDARY_LINE } from '../session/cli-record.js';
 import { formatInfo } from '../renderer/notice-shape.js';
 import { recordFullNotice } from '../renderer/notice-log.js';
 import { paint } from '../renderer/theme.js';
@@ -35,7 +36,11 @@ export async function compactAtPhaseBoundary(session, summarise) {
     if (!summary || summary.trim().length === 0)
         throw new Error('the summary came back empty');
     const backupPath = await backupBeforeCompact(session);
+    const oldMessages = session.messages;
     session.messages = [buildPhaseBoundaryMessage(summary)];
+    // /export docx conversation: the summary is CSPeach's, not the developer's (one plain line there).
+    // Every earlier message is dropped: the record holds only the summary's mark.
+    rebuildCliMarksAfterCompact(session, oldMessages, oldMessages.length, session.messages[0].content, { kind: 'plan-boundary', line: PLAN_BOUNDARY_LINE });
     delete session.last_context_tokens;
     await saveSession(session);
     return { performed: true, backupPath };

package/dist/commands/plan-continue.js

@@ -29,6 +29,17 @@ function stepTitle(envelope, phaseId) {
     const p = pc.ok ? pc.content.phases.find((q) => q.id === phaseId) : undefined;
     return p && pc.ok ? phaseDisplayTitle(p, pc.content.phases) : 'the interrupted step';
 }
+/**
+ * /export docx conversation (2026-10-23): the one line that stands for a plan
+ * step prompt CSPeach wrote, e.g. "CSPeach ran plan step 2 (Skeleton)."
+ */
+export function planStepOriginLine(prepared) {
+    const pc = parsePlanContent(prepared.envelope.content);
+    const i = pc.ok ? pc.content.phases.findIndex((q) => q.id === prepared.nextPhaseId) : -1;
+    if (!pc.ok || i < 0)
+        return 'CSPeach ran the next plan step.';
+    return `CSPeach ran plan step ${i + 1} (${phaseDisplayTitle(pc.content.phases[i], pc.content.phases)}).`;
+}
 /** The one line shown when a bare "continue" re-attaches to an interrupted step. */
 export function continuationNotice(prepared) {
     return `Continuing ${stepTitle(prepared.envelope, prepared.nextPhaseId)} where it stopped`;

package/dist/commands/plan-reground.js

@@ -99,10 +99,28 @@ export async function regroundPlan(a) {
                 stillLocked.push(o.name);
         }
         let transportClosed = false;
+        let listed = null;
+        const isListed = (t, tr) => t.list.some((x) => x.trim().toUpperCase() === tr.trim().toUpperCase());
         if (transport) {
             const t = await a.deps.openTransports();
-            transportClosed = t.complete && !t.list.some((x) => x.trim().toUpperCase() === transport.trim().toUpperCase());
+            listed = t;
+            transportClosed = t.complete && !isListed(t, transport);
         }
+        // The step transport counts as open only when SAP lists it. Any failure
+        // here keeps the old text and a "not open" verdict.
+        const step = a.stepTransport?.trim();
+        let stepOpen = false;
+        if (step) {
+            try {
+                listed = listed ?? await a.deps.openTransports();
+                stepOpen = isListed(listed, step);
+            }
+            catch (err) {
+                recordFullNotice('plan', `Transport check before a plan step failed: ${errText(err)}`);
+            }
+        }
+        const openStepTransport = !transport && stepOpen ? step : null;
+        const verdict = step ? { stepTransportOpen: stepOpen } : {};
         // An object left inactive gets the inactive instruction only, never the
         // "do not rewrite" one as well.
         const inactiveNames = new Set(inactive.map((o) => o.name));
@@ -124,7 +142,9 @@ export async function regroundPlan(a) {
                 ? (transportClosed
                     ? `- The plan's transport ${transport} is no longer open. Do not write to it. Creating a new transport needs the developer's approval (it is not on the approved list).`
                     : `- Transport ${transport} is still open: use it.`)
-                : '- No transport is recorded yet: the first writing step creates one.',
+                : openStepTransport
+                    ? `- Transport ${openStepTransport} is open: use it.`
+                    : '- No transport is recorded yet: the first writing step creates one.',
             '</sap_state>',
         ];
         if (stillLocked.length > 0) {
@@ -133,12 +153,14 @@ export async function regroundPlan(a) {
                 ok: false, reason: 'locked',
                 lines: [`${stillLocked.join(', ')} ${one ? 'is' : 'are'} still locked by another session. SAP frees ${one ? 'it' : 'them'} when that session ends or times out, usually within a few minutes.`],
                 sapStateBlock: block,
+                ...verdict,
             };
         }
         const n = inactive.length;
         const summary = `Checked SAP before continuing: ${n} object${n === 1 ? '' : 's'} left inactive`
-            + (transport ? `, transport ${transport} ${transportClosed ? 'no longer open' : 'still open'}` : '') + '.';
-        return { ok: true, summary, quiet: n === 0 && !transportClosed, sapStateBlock: block };
+            + (transport ? `, transport ${transport} ${transportClosed ? 'no longer open' : 'still open'}` : '')
+            + (openStepTransport ? `, transport ${openStepTransport} open` : '') + '.';
+        return { ok: true, summary, quiet: n === 0 && !transportClosed, sapStateBlock: block, ...verdict };
     }
     catch (err) {
         const code = unreachableOf(err);
@@ -158,6 +180,7 @@ export async function regroundPlan(a) {
                 built.length > 0 ? `- Already built by earlier steps of this plan: ${built.join(', ')}.` : '- No earlier step of this plan has built SAP objects yet.',
                 '</sap_state>',
             ],
+            ...(a.stepTransport?.trim() ? { stepTransportOpen: false } : {}),
         };
     }
 }