@cspeach/cli 1.1.50 → 1.1.51

package/dist/agent/loop.js

@@ -45,7 +45,9 @@ import { resetRule8State, shouldGateRule8 } from '../repl/rule8-detector.js';
 import { consumeTodoSetThisTurn } from '../ui/todo-emitter.js';
 import { runSaveCommand, runPromoteCommand, detectArtifactSkill, offerAnswerBlockers } from '../projects/index.js';
 import { planLaneBlockForTurn } from '../projects/plan-lane.js';
-import { DOCUMENT_SKILLS } from '../projects/document-skills.js';
+import { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE } from '../projects/document-skills.js';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { bindCliCardSession, documentOffersFor, markCliMessage, CONTINUE_LINE, WATCHDOG_LINE } from '../session/cli-record.js';
 import { clearAppFlow, getAppFlow, setGapConfirmed, startAppFlow } from '../lane/app-flow.js';
 import { getLatestSkeletonDecision } from '../rap/skeleton-session.js';
 import { afterRebuildTurn } from '../journey/rebuild.js';
@@ -373,6 +375,69 @@ export async function inkAwareChoose(a) {
     emitTrace(formatAnswerTrace(header, shown, uiWidth()));
     return { kind: 'picked', answer };
 }
+/**
+ * Word copy everywhere (2026-10-23) — a newer document skill offers the save
+ * only when its answer is shaped like a document: at least one Markdown
+ * heading. A short answer to a quick question ("what is clean core?") is
+ * not offered. Review/handover do not use this check (unchanged).
+ */
+function looksLikeDocument(text) {
+    return /^#{1,6}\s+\S/m.test(text);
+}
+const OBJECT_TOKEN_RE = /(?<![\w/])((?:\/[A-Za-z0-9]+\/)?[ZYzy][A-Za-z0-9_]{2,39})\b/g;
+/**
+ * The first Z/Y object name in the prompt (final-review m-2): a name with an
+ * underscore (zcl_order, ZFI_DUP_INVOICE_CHECK), or one typed in capitals with
+ * at least 4 characters (ZTEST). Ordinary words never count: you, yes, YES, YOU.
+ */
+export function promptObjectName(prompt) {
+    for (const m of prompt.matchAll(OBJECT_TOKEN_RE)) {
+        const t = m[1];
+        if (t.includes('_') || (t.length >= 4 && t === t.toUpperCase()))
+            return t.toUpperCase();
+    }
+    return undefined;
+}
+/**
+ * Note this turn's (skill, object). `fresh` is false only when the key was
+ * already offered in this session (final-review I-3: a clarifying question
+ * before the document no longer uses up the offer). Without a session: always
+ * fresh (no rule). The offers are cleared by /new (session/cli-record.ts).
+ */
+function noteDocumentTurn(p) {
+    if (!p.session)
+        return { fresh: true, markOffered: () => { } };
+    const object = metaFromMarkdown(p.assistantText, { date: '' }).object ?? promptObjectName(p.userMessage) ?? '';
+    const key = `${p.skill}|${object}`;
+    const offered = documentOffersFor(p.session);
+    return { fresh: !offered.has(key), markOffered: () => { offered.add(key); } };
+}
+/** Today's local date, YYYY-MM-DD (the document file names use it). */
+function localToday() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+/**
+ * The Word step after an artefact save. document-save.ts (and the docx
+ * package) loads only here, inside the catch: a broken docx install costs
+ * one line after the save and never the save itself.
+ */
+async function offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm) {
+    try {
+        const { offerWordCopyAfterArtifactSave } = await import('../projects/document-save.js');
+        const { isHeadless } = await import('../renderer/tty.js');
+        const { loadConfig, resolveWordCopy } = await import('../config/loader.js');
+        await offerWordCopyAfterArtifactSave({
+            saveSkill, savedPath, markdown: p.assistantText, cwd: process.cwd(), sapSystem: p.sapSystem ?? null,
+            // Inside a guided flow the Word step never asks: same rule as headless.
+            today: localToday(), headless: isHeadless() || p.guided === true, wordCopy: resolveWordCopy(await loadConfig()),
+            confirm, emit: p.emit,
+        });
+    }
+    catch (e) {
+        p.emit(formatInfo(`Word copy not written: ${e.message}`).trimEnd());
+    }
+}
 export async function maybeOfferSave(p) {
     if (p.assistantText.trim().length === 0)
         return;
@@ -383,7 +448,26 @@ export async function maybeOfferSave(p) {
     // The skill check reads a tiny constant module; document-save.ts (and the
     // docx package) loads only for these two skills, inside the catch, so a
     // broken docx install costs one line on a review save and nothing else.
-    if (DOCUMENT_SKILLS[p.skill]) {
+    // Word copy everywhere (2026-10-23): the newer document skills (explain,
+    // impact, preflight, …) yield to the artefact save when their answer
+    // carries an artefact block, and offer nothing when the turn ended on a
+    // question. Review and handover take this branch exactly as before.
+    const confirm = p.confirm ?? inkAwareConfirm;
+    const doc = DOCUMENT_SKILLS[p.skill];
+    // Fix round 1 (I-3): which skill and object this turn was about (every turn,
+    // so a follow-up of the same skill on the same object is known).
+    const docTurn = noteDocumentTurn(p);
+    let offerDoc = doc !== undefined;
+    if (doc?.yieldsToArtifact) {
+        // Headless runs of the newer document skills write no file (scripts and CI
+        // keep today's behaviour). Review and handover keep theirs.
+        // A sub-agent turn never saves, so it never uses up the offer (final-review m-1).
+        offerDoc = !p.subagent && docTurn.fresh && !(await import('../renderer/tty.js')).isHeadless() && !p.awaitingAnswer && !p.guided
+            && looksLikeDocument(p.assistantText) && !detectArtifactSkill(p.assistantText);
+        if (offerDoc)
+            docTurn.markOffered();
+    }
+    if (doc && offerDoc) {
         if (p.subagent)
             return;
         const d = new Date();
@@ -395,7 +479,7 @@ export async function maybeOfferSave(p) {
             await offerDocumentSave({
                 skill: p.skill, markdown: p.assistantText, cwd: process.cwd(), sapSystem: p.sapSystem ?? null,
                 today, headless: isHeadless(), wordCopy: resolveWordCopy(await loadConfig()),
-                confirm: inkAwareConfirm, emit: p.emit,
+                confirm, emit: p.emit,
             });
         }
         catch (e) {
@@ -471,6 +555,13 @@ export async function maybeOfferSave(p) {
             // Never headless: a headless journey queues nothing.
             ...(p.journey && !isHeadless() && p.skill === saveSkill ? { journey: p.journey } : {}),
         });
+        // Word copy everywhere (2026-10-23) — a saved project file whose answer
+        // is a document (spec gaps, design, estimate, plan, upgrade scan/report)
+        // gets the same Word step as a review: `word_copy` decides, headless
+        // never asks. The project file itself is untouched. Sub-agent turns: no.
+        if (savedPath && !p.subagent && WORD_AFTER_ARTIFACT_SAVE[saveSkill]) {
+            await offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm);
+        }
         // After a spec-gap file is saved, let a developer answer the open BLOCKER
         // questions inline (recorded as `answered` items in the SAME file) — the
         // business questions stay open for a consultant to answer in the viewer.
@@ -988,6 +1079,12 @@ ${imageExpansion.error}`));
     // Images (if any) ride as blocks ahead of the text; with none this is the
     // same plain string as before.
     session.messages.push({ role: 'user', content: buildUserContent(finalUserContent, imageExpansion.images) });
+    if (params.userMessageOrigin) {
+        markCliMessage(session, session.messages[session.messages.length - 1].content, params.userMessageOrigin.kind, params.userMessageOrigin.line);
+    }
+    // The CLI cards answered during this turn (plan gate, lane, journey) belong to this session.
+    if (!params.ctx.subagent && !readerChild)
+        bindCliCardSession(session);
     // Round 6 review I4 / final batch 1 — the switch note is dropped only once
     // it is in a pushed user message.
     if (switchNoteUsed)
@@ -1196,6 +1293,7 @@ ${imageExpansion.error}`));
             if (steers.length > 0) {
                 const text = steers.join('\n');
                 session.messages.push({ role: 'user', content: text });
+                markCliMessage(session, text, 'steer', '');
                 if (roundIndex === 0)
                     round0Steers = steers;
                 emit(chalk.cyan(`↳ steering: ${steers.join(' / ')}`));
@@ -2042,6 +2140,9 @@ ${imageExpansion.error}`));
                         emit,
                         sapSystem: session.sap_system,
                         ...(params.ctx.subagent ? { subagent: true } : {}),
+                        ...(session.awaitingSkillAnswer === true ? { awaitingAnswer: true } : {}),
+                        ...(getJourneyFlow(session) || getAppFlow(session) ? { guided: true } : {}),
+                        session,
                         promotedFrom: promotedFromForSave,
                         ...(promotedFromPathForSave ? { promotedFromPath: promotedFromPathForSave } : {}),
                         ...(() => {
@@ -2195,6 +2296,7 @@ ${imageExpansion.error}`));
                         + 'If you were mid-way through a tool call, or (for /abap-plan) had not yet emitted the closing cspeach:plan-manifest block, complete it now. '
                         + 'Keep narration brief to stay within the limit.',
                 });
+                markCliMessage(session, session.messages[session.messages.length - 1].content, 'continue', CONTINUE_LINE);
                 continue;
             }
             if (sawMaxTokens) {
@@ -2546,6 +2648,7 @@ ${imageExpansion.error}`));
                 watchdogWarned = true;
                 emit(chalk.yellow(`\n[watchdog] ${decision.reason}. Asking the model to wrap up.`));
                 session.messages.push({ role: 'user', content: decision.message });
+                markCliMessage(session, decision.message, 'watchdog', WATCHDOG_LINE);
                 await saveSession(session);
             }
         }

package/dist/cli.js

@@ -308,7 +308,7 @@ Usage:
   cspeach                           Start interactive REPL
   cspeach "<prompt>"                One-shot — runs one turn and exits
   cspeach --one-shot "<prompt>"     Same as above, explicit flag
-  cspeach export <file>.md --docx   Write a Word copy next to a saved review or handover
+  cspeach export <file>.md --docx   Write a Word copy next to a Markdown file
   cspeach --sap-alias <name>        Use a specific SAP alias (overrides default)
   cspeach --no-sap                  Start without a SAP system (paste-mode skills only)
   cspeach --continue, -c            Continue the latest session in this folder

package/dist/commands/compact.js

@@ -33,6 +33,7 @@ import { paint } from '../renderer/theme.js';
 import { getGlyphs } from '../renderer/glyphs.js';
 import { saveSession } from '../session/store.js';
 import { isUserPrompt } from '../session/user-prompt.js';
+import { rebuildCliMarksAfterCompact, COMPACT_LINE } from '../session/cli-record.js';
 import { getActiveDeployments } from '../models/model-identity.js';
 /** Keep this many recent user-prompt anchored turns verbatim. */
 export const KEEP_RECENT_TURNS = 5;
@@ -305,7 +306,12 @@ export async function runCompact(opts) {
     // that produced it). The summary changed them, so the kept tail goes out
     // without thinking; text and tool calls stay. The backup above keeps all.
     const kept = plan.toKeep.map(stripThinking);
+    const oldMessages = session.messages;
     session.messages = [summaryMsg, ...kept];
+    // /export docx conversation: the summary is CSPeach's, not the developer's
+    // (one plain line there). The record is rebuilt in message order so the kept
+    // plan steps, continuations and steers keep their marks (final-review I-1).
+    rebuildCliMarksAfterCompact(session, oldMessages, plan.cutAt, summaryMsg.content, { kind: 'compact', line: COMPACT_LINE });
     // Task 19 — the recorded context size described the old history; the next
     // call records the new one. Clearing it keeps the auto-compact gate honest.
     delete session.last_context_tokens;

package/dist/commands/config-set.js

@@ -616,7 +616,7 @@ export async function runConfigSet(args) {
             if (b === null)
                 err(`${key} must be on/off (also accepts true/false, 1/0).`);
             cfg.word_copy = b;
-            console.log(chalk.dim(b ? '  → a Word copy is written with every saved review or handover.' : '  → CSPeach will not ask about Word copies.'));
+            console.log(chalk.dim(b ? '  → a Word copy is written with every document CSPeach saves.' : '  → CSPeach will not ask about Word copies.'));
             break;
         }
         case 'write_mode':

package/dist/commands/export-audit.js

@@ -17,10 +17,33 @@ import path from 'node:path';
 import { buildAuditReport } from '../session/audit-export.js';
 import { globalCredits } from '../cost/credits.js';
 import { readCostLog } from '../cost/cost-log.js';
-/** Parse the text after `/export` into a subcommand + optional filename. */
+/**
+ * The /export usage line (2026-10-23). Here, in the light audit module both
+ * REPL handlers already load, so `/export audit` and a mistyped `/export`
+ * never load the Word package (final-review I-2).
+ */
+export const EXPORT_REPL_USAGE = 'Usage: /export docx (the last answer to Word) · /export docx <name> · /export docx conversation · /export audit [file]';
+/**
+ * Parse the text after `/export` into a subcommand + optional filename.
+ *
+ * 2026-10-23 (a customer's screenshot): the Word forms people actually type
+ * all mean "Word": `/export docx x.docx`, `/export x.md --docx`,
+ * `/export x.docx`, `/export conversation`, `/export word`. A `--docx` or
+ * `--word` flag anywhere is dropped. For sub 'docx', `docxArgs` is the line
+ * to hand to runExportDocxRepl (" docx <rest>").
+ */
 export function parseExportArgs(rest) {
-    const parts = rest.trim().split(/\s+/).filter(Boolean);
-    return { sub: (parts[0] ?? '').toLowerCase(), filename: parts[1] };
+    let flag = false;
+    const cleaned = rest.replace(/(^|\s)--(?:docx|word)(?=\s|$)/gi, () => { flag = true; return ' '; }).trim();
+    const parts = cleaned.split(/\s+/).filter(Boolean);
+    const first = (parts[0] ?? '').toLowerCase();
+    if (first === 'docx' || first === 'word') {
+        return { sub: 'docx', docxArgs: ` docx ${cleaned.slice(parts[0].length).trim()}`.trimEnd() };
+    }
+    if (first !== 'audit' && (flag || first === 'conversation' || /\.(?:md|docx)["']?$/i.test(cleaned))) {
+        return { sub: 'docx', docxArgs: ` docx ${cleaned}`.trimEnd() };
+    }
+    return { sub: first, filename: parts[1] };
 }
 /** Deterministic default filename: date from session data, not now(). */
 export function defaultAuditFilename(session) {

package/dist/commands/export-conversation.js

@@ -0,0 +1,343 @@
+// 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 { 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. */
+const INJECTED_TAGS = ['session_context', 'project_context', 'journey', 'lane_decision', 'system_switch', 'sap_system', 'sap_connection'];
+function typedText(text) {
+    let out = text;
+    for (const tag of INJECTED_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/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`;