@cspeach/cli 1.1.50 → 1.1.51

package/dist/commands/plan-startup.js

@@ -20,6 +20,7 @@ import { computeNextPhaseForRun, isPhaseSatisfiedForRun, phaseDisplayTitle, stat
 import { collectPlannedObjects, plannedObjectFacts, planGrantFactLines } from '../projects/plan-objects.js';
 import { adoptPlanTransportOnResume, buildResumeCommand, planBuildTransport } from './plan-resume.js';
 import { newestPlanFamilyFiles } from '../session/recap.js';
+import { recordCliCard } from '../session/cli-record.js';
 import { legacyDirsFor } from '../projects/project-folder.js';
 import { getPlanGrant, installPlanGrant, planGrantAllowed } from '../approvals/plan-grant.js';
 import { DEFAULT_PLAN_MODE } from './plan-gate.js';
@@ -256,6 +257,9 @@ export function classicStartupChooser(prompt, log) {
         log('', q.title, ...q.facts.map((f) => `  ${f}`), ...q.choices.map((c, i) => `  ${i + 1}. ${c.label}`));
         const ans = (await prompt(`Choose 1-${q.choices.length} (Enter = ${q.choices[0].label}): `)).trim();
         const n = ans === '' ? 1 : Number(ans);
-        return Number.isInteger(n) && n >= 1 && n <= q.choices.length ? q.choices[n - 1].value : null;
+        const picked = Number.isInteger(n) && n >= 1 && n <= q.choices.length ? q.choices[n - 1] : null;
+        // /export docx conversation: the classic startup choice is recorded like the Ink card.
+        recordCliCard({ question: q.title, options: q.choices.map((c) => c.label), ...(q.facts.length ? { facts: [...q.facts] } : {}), answer: picked?.label ?? 'Cancelled', by: 'user' });
+        return picked ? picked.value : null;
     };
 }

package/dist/docx/doc-meta.js

@@ -3,7 +3,15 @@
 // The metadata a Word copy carries on its title page. Filled by the caller
 // (the save hook knows the session's SAP alias; the export command knows the
 // file) and, for what the text itself says, by metaFromMarkdown (Task 3).
-const KIND_TITLE = { review: 'Code review', handover: 'Handover', document: 'Document' };
+const KIND_TITLE = {
+    review: 'Code review', handover: 'Handover', document: 'Document',
+    explanation: 'Explanation', impact: 'Impact analysis', preflight: 'Preflight check',
+    'transport-analysis': 'Transport analysis', migration: 'Migration assessment',
+    'clean-core': 'Clean-core assessment', 'custom-code-analysis': 'Custom code analysis',
+    'spec-gap': 'Spec gaps', design: 'Design', estimate: 'Estimate', plan: 'Plan',
+    'upgrade-scan': 'Upgrade scan', 'upgrade-report': 'Upgrade report',
+    answer: 'CSPeach answer', conversation: 'CSPeach conversation',
+};
 /** Z/Y objects, SAP-style names: ZCL_X, ZFI_DUP_INVOICE_CHECK, Z_REPORT, /NS/ZCL_X. */
 const OBJECT_RE = /(?<![\w/])((?:\/[A-Z0-9]+\/)?[ZY][A-Z0-9_]{2,39})\b/;
 /** Inline Markdown → plain words: `code` → code, [text](url) → text, **x** → x. */

package/dist/docx/markdown-to-docx.js

@@ -63,6 +63,10 @@ function titlePage(meta) {
         facts.push(`System: ${meta.system}`);
     if (meta.object)
         facts.push(`Object: ${meta.object}`);
+    if (meta.session)
+        facts.push(`Session: ${meta.session}`);
+    if (meta.person)
+        facts.push(`Signed in as: ${meta.person}`);
     return [
         new Paragraph({ text: meta.title, heading: HeadingLevel.TITLE, spacing: { before: 2400 } }),
         ...facts.map((f) => new Paragraph({ text: f })),
@@ -120,18 +124,27 @@ function list(l, ctx, depth) {
         const mark = l.ordered
             ? { numbering: { reference: NUMBERED, level, instance } }
             : { bullet: { level } };
+        // Task-list items (`- [ ]` / `- [x]`) keep their box at the start of the item (2026-10-23).
+        const box = item.task ? (item.checked ? '☒ ' : '☐ ') : '';
         let first = true;
         for (const child of item.tokens) {
             if (child.type === 'list') {
                 out.push(...list(child, ctx, depth + 1));
                 continue;
             }
+            if (first && box && (child.type === 'text' || child.type === 'paragraph')) {
+                const p = child;
+                const kids = 'tokens' in p && p.tokens ? inline(p.tokens) : [new TextRun(p.text ?? p.raw ?? '')];
+                out.push(new Paragraph({ ...mark, children: [new TextRun(box), ...kids] }));
+                first = false;
+                continue;
+            }
             // The first text block of an item carries the marker; later paragraphs are indented plain text.
             out.push(...blockToDocx(child, ctx, depth, first ? mark : { indent: { left: 720 * (level + 1) } }));
             first = false;
         }
         if (first)
-            out.push(new Paragraph({ ...mark, text: item.text ?? '' }));
+            out.push(new Paragraph({ ...mark, text: box + (item.text ?? '') }));
     }
     return out;
 }

package/dist/lane/app-chain.js

@@ -30,6 +30,7 @@ import { containSpecPath, specDisplayPath, SpecProtectedError } from './roots.js
 import { resolveAtTokenAsync } from '../projects/workspace.js';
 import { parseFromFlag } from '../skills/promotion-dispatch.js';
 import { rebuildStartedAfterPlanSave } from '../journey/rebuild.js';
+import { recordCliCard } from '../session/cli-record.js';
 export const STEP_1 = 'Step 1 of 3: finding the gaps in the spec.';
 export const STEP_2 = 'Step 2 of 3: choosing the build lane.';
 export const STEP_3 = 'Step 3 of 3: planning the build.';
@@ -239,6 +240,10 @@ function readSavedPlan(savedPath) {
     }
 }
 const OBJECT_LIST_FAILED = 'The object list could not be approved. Each SAP write asks first.';
+/** The plan a "Build this now?" record is about: the plan file name and its version. */
+function planRef(savedPath, version) {
+    return `${savedPath.split(/[\\/]/).pop() ?? savedPath} v${version}`;
+}
 /**
  * The facts under "Build this now?": steps, the exact object list, transport,
  * deploy, what stops. `grant: false` (the object-list approval cannot be
@@ -367,6 +372,9 @@ export async function afterPlanSave(h, savedPath) {
         return;
     }
     if (h.headless || !h.queueNext) {
+        // /export docx conversation: the plan gate was not shown; say so in the record.
+        if (h.headless)
+            recordCliCard({ question: START_QUESTION, ref: planRef(savedPath, saved.envelope.version), answer: 'Not asked (no one at the terminal)', by: 'headless' }, h.session);
         h.emit(`Start building with: ${cmd}`);
         end();
         return;
@@ -389,27 +397,42 @@ export async function afterPlanSave(h, savedPath) {
         initial: 0,
         aliases: { y: 'yes', n: 'no' },
     });
+    // /export docx conversation (fix round 2, N-1): the record a change ticket
+    // needs — when, which plan file and version, the objects and transport shown,
+    // the answer, and whether the object-list approval was installed. Only when
+    // a card was really shown (an injected confirm, or a card listener).
+    const shown = h.confirm !== undefined || (await import('../ui/card-slot.js')).cardSlotEmitter.listenerCount('confirm') > 0;
+    const record = (answer) => {
+        if (shown)
+            recordCliCard({ question: START_QUESTION, ref: planRef(savedPath, saved.envelope.version), options: ['Yes', 'No'], facts: [...facts], answer, by: 'user' }, h.session);
+    };
     if (res.value === 'yes' && !res.cancelled) {
         // The plan's recorded transport becomes the session transport when the
         // session has none, so the first step's writes land on (and are covered
         // by) it without the model naming it — the same rule a resume uses.
         adoptPlanTransportOnResume(saved.content.phases);
         const sessionId = h.session.id;
+        let installed = true;
         if (grantable && objects.length > 0 && typeof sessionId === 'string' && sessionId) {
             const a = { planId: saved.envelope.id, sessionId, objects, ...(transport ? { transport } : {}) };
             try {
                 if (h.grant)
                     await h.grant(a);
-                else if (!(await installPlanGrant({ ...a, ...(sapAlias ? { sapAlias } : {}) })))
+                else if (!(await installPlanGrant({ ...a, ...(sapAlias ? { sapAlias } : {}) }))) {
+                    installed = false;
                     h.emit(OBJECT_LIST_FAILED);
+                }
             }
             catch {
+                installed = false;
                 h.emit(OBJECT_LIST_FAILED);
             }
         }
+        record(installed ? 'Yes' : 'Yes (object list not installed; each SAP write asks first)');
         h.queueNext(cmd, APP_ORIGIN);
     }
     else {
+        record(res.value === 'no' ? 'No' : 'Cancelled');
         h.emit(`Start it later with: ${cmd}`);
     }
     end();

package/dist/projects/document-save.js

@@ -1,7 +1,8 @@
 // cspeach-cli/src/projects/document-save.ts
 //
-// The save for the two document skills (2026-10-19, owner decision 2026-10-17).
-// A review or a handover is prose, not an envelope: it goes to
+// The save for the document skills (2026-10-19, owner decision 2026-10-17;
+// widened 2026-10-23, Word copy everywhere — see document-skills.ts).
+// A review, a handover, an explanation, … is prose, not an envelope: it goes to
 // <cwd>/cspeach-out/<date>-<kind>-<OBJECT>.md (the folder the model already
 // writes extra copies to; skipped by the @-picker; exempt from the Rule 8
 // card). Then one question, "Word copy too?", unless `word_copy` decides.
@@ -13,8 +14,9 @@ import { askYesNo, isYes } from './yes-no.js';
 import { metaFromMarkdown } from '../docx/doc-meta.js';
 import { writeDocxNextTo, writeNoClobber } from '../docx/write-docx.js';
 import { safeFileStem } from '../register/xlsx.js';
-import { DOCUMENT_SKILLS } from './document-skills.js';
-export { DOCUMENT_SKILLS };
+import { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE } from './document-skills.js';
+import { handoverPathFor } from './handover-md.js';
+export { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE };
 export const OUT_DIR = 'cspeach-out';
 export function documentFilename(kind, object, date) {
     const stem = safeFileStem((object ?? 'document').replace(/\//g, ''));
@@ -44,19 +46,74 @@ export async function offerDocumentSave(p) {
         return {};
     }
     p.emit(`Saved: ${path.resolve(mdPath)}`);
+    const docxPath = await offerWordCopy({
+        // Fix round 1 (m-1): the newer document skills' Word copy leaves out HTML comments
+        // (widget markers); review and handover pass their text exactly as before.
+        nextTo: mdPath, markdown: skill.yieldsToArtifact ? p.markdown.replace(/<!--[\s\S]*?-->\s*/g, '') : p.markdown, meta, headless: p.headless, wordCopy: p.wordCopy, confirm: p.confirm, emit: p.emit,
+    });
+    return docxPath ? { mdPath, docxPath } : { mdPath };
+}
+/**
+ * The Word step, shared by every save of a document (Word copy everywhere,
+ * 2026-10-23). `word_copy` decides: unset → ask "Word copy too?", on →
+ * always, off → never. Headless never asks: the copy is written only when
+ * `word_copy` is on. Never overwrites, never throws: a failure is one line.
+ * Returns the .docx path when one was written.
+ */
+export async function offerWordCopy(p) {
     let wantWord = p.wordCopy === 'always';
     if (p.wordCopy === 'ask' && !p.headless) {
         wantWord = isYes(await askYesNo({ question: 'Word copy too?', confirm: p.confirm }));
     }
     if (!wantWord)
-        return { mdPath };
+        return undefined;
     try {
-        const docxPath = await writeDocxNextTo(mdPath, p.markdown, meta);
+        const docxPath = await writeDocxNextTo(p.nextTo, p.markdown, p.meta);
         p.emit(`Word copy: ${path.resolve(docxPath)}`);
-        return { mdPath, docxPath };
+        return docxPath;
     }
     catch (e) {
         p.emit(`Word copy not written. ${e.message}`);
-        return { mdPath };
+        return undefined;
+    }
+}
+/** Artefact blocks (`<!-- cspeach:…-manifest … -->`, legacy `csforge:` too) are for CSPeach, not for the reader. */
+const ARTIFACT_BLOCK_RE = /<!--\s*(?:csforge|cspeach):[\w-]+\s*\n[\s\S]*?-->\s*/g;
+/** The YAML header at the top of a plan's handover Markdown. */
+const FRONT_MATTER_RE = /^---\r?\n[\s\S]*?\r?\n---\r?\n/;
+/** The text a person reads: no artefact blocks; the YAML header only for a plan handover (final-review m-3). */
+export function readerMarkdown(markdown, frontMatter = true) {
+    return (frontMatter ? markdown.replace(FRONT_MATTER_RE, '') : markdown).replace(ARTIFACT_BLOCK_RE, '').trim() + '\n';
+}
+/**
+ * The Word step after an artefact save ("Save as project file?" said Yes).
+ * The project file is the source of truth and is never touched here; the
+ * .docx is a copy for people and is never read back.
+ * - a plan: the copy is made from the plan's handover Markdown, next to it
+ *   (that file is written by the plan save, exactly as before);
+ * - the others: from the answer, into cspeach-out/<date>-<kind>-<OBJECT>.docx.
+ * Skills not in WORD_AFTER_ARTIFACT_SAVE: nothing.
+ */
+export async function offerWordCopyAfterArtifactSave(p) {
+    const kind = WORD_AFTER_ARTIFACT_SAVE[p.saveSkill];
+    if (!kind)
+        return undefined;
+    const handover = kind === 'plan' ? handoverPathFor(p.savedPath) : null;
+    let source = p.markdown;
+    if (handover) {
+        try {
+            source = await fs.promises.readFile(handover, 'utf8');
+        }
+        catch {
+            return undefined; // the plan save already said the handover was not written
+        }
     }
+    const markdown = readerMarkdown(source, handover !== null);
+    if (markdown.trim().length === 0)
+        return undefined;
+    const meta = metaFromMarkdown(markdown, { date: p.today, kind, ...(p.sapSystem ? { system: p.sapSystem } : {}) });
+    const nextTo = handover ?? path.join(p.cwd, OUT_DIR, documentFilename(kind, meta.object, p.today));
+    return offerWordCopy({
+        nextTo, markdown, meta, headless: p.headless, wordCopy: p.wordCopy, confirm: p.confirm, emit: p.emit,
+    });
 }

package/dist/projects/document-skills.js

@@ -1,9 +1,40 @@
 // cspeach-cli/src/projects/document-skills.ts
 //
-// The two document skills, on their own so the agent loop can check a skill
+// The document skills, on their own so the agent loop can check a skill
 // name without loading document-save.ts (and the docx package behind it) on
 // every turn. Type-only import: nothing heavy loads from here.
+//
+// Word copy everywhere (2026-10-23, owner: "add this word feature everywhere"):
+// - DOCUMENT_SKILLS: skills whose answer is a document a person keeps. After
+//   the turn: "Save this <noun> to a file?" (cspeach-out/<date>-<kind>-<OBJECT>.md),
+//   then the Word step. Review and handover were the first two (2026-10-19);
+//   the others join with `yieldsToArtifact`: when their answer carries a
+//   recognizable artefact block (a plan, a clean-core triage, …) the artefact
+//   save runs instead, exactly as before.
+// - WORD_AFTER_ARTIFACT_SAVE: artefact saves (a .cspeach.json project file)
+//   whose answer is also a document. After "Save as project file?" says Yes,
+//   the same Word step runs. The project file and its save do not change.
 export const DOCUMENT_SKILLS = {
     'abap-review': { kind: 'review', noun: 'review' },
     'abap-handover': { kind: 'handover', noun: 'handover' },
+    'abap-explain': { kind: 'explanation', noun: 'explanation', yieldsToArtifact: true },
+    'abap-impact': { kind: 'impact', noun: 'impact analysis', yieldsToArtifact: true },
+    'abap-preflight': { kind: 'preflight', noun: 'preflight check', yieldsToArtifact: true },
+    'abap-transport-analysis': { kind: 'transport-analysis', noun: 'transport analysis', yieldsToArtifact: true },
+    'abap-migrate': { kind: 'migration', noun: 'migration assessment', yieldsToArtifact: true },
+    'abap-clean-core': { kind: 'clean-core', noun: 'clean-core assessment', yieldsToArtifact: true },
+    'abap-cca': { kind: 'custom-code-analysis', noun: 'custom code analysis', yieldsToArtifact: true },
+};
+/**
+ * Artefact saves that also get the Word step (skill name as saved → kind).
+ * A plan's Word copy is made from its handover Markdown (written next to the
+ * plan file); the others from the answer the person read.
+ */
+export const WORD_AFTER_ARTIFACT_SAVE = {
+    'abap-spec-gap': 'spec-gap',
+    'abap-design': 'design',
+    'abap-estimate': 'estimate',
+    'abap-plan': 'plan',
+    'abap-upgrade-scan': 'upgrade-scan',
+    'abap-upgrade-verify': 'upgrade-report',
 };

package/dist/repl/builtin-commands.js

@@ -33,7 +33,7 @@ export const BUILTIN_ENTRIES = [
     { name: '/cost', get description() { return costCommandDescription(); } },
     { name: '/usage', get description() { return usageCommandDescription(); } },
     { name: '/compact', description: 'Shrink a long session and keep the facts (later turns cost far less)' },
-    { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy of a saved file (/export docx <file>.md)' },
+    { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy: of the last answer (/export docx, or /export docx <name>), of the whole conversation (/export docx conversation) or of a Markdown file (/export docx <file>.md)' },
     { name: '/context', description: 'Show what fills the model context window — a composition grid of bars' },
     { name: '/exit', description: 'Exit CSPeach' },
     { name: '/quit', description: 'Exit CSPeach (alias)' },

package/dist/repl/slash-completer.js

@@ -25,6 +25,10 @@ const BUILTIN_COMMANDS = [
     '/usage',
     '/context',
     '/export',
+    // 2026-10-23: Tab after `/export ` offers the subcommands.
+    '/export audit',
+    '/export docx',
+    '/export docx conversation',
     '/exit',
     '/quit',
     '/help',

package/dist/repl.js

@@ -208,6 +208,17 @@ import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
 import './tools/subagent/read_agent.js';
 import { folderTag, currentFolderKey } from './session/project-match.js';
+import { bindCliCardSession } from './session/cli-record.js';
+/** /export docx conversation (2026-10-23) — the origin of a turn CSPeach started itself. */
+async function cliTurnOrigin(planResume, queuedCmd) {
+    if (planResume) {
+        const { planStepOriginLine } = await import('./commands/plan-continue.js');
+        return { userMessageOrigin: { kind: 'plan-step', line: planStepOriginLine(planResume) } };
+    }
+    if (queuedCmd)
+        return { userMessageOrigin: { kind: 'queued', line: `CSPeach ran the next step: ${queuedCmd.trim()}` } };
+    return {};
+}
 const HISTORY_SIZE = 500;
 // Persistence (read + dedup-guarded append) lives in ./repl/history.ts —
 // the single writer shared with the Ink Footer (Task 8, ux-wave1).
@@ -793,6 +804,8 @@ export async function runRepl(opts) {
     // served config), marks it 'predicted', saves, then stays pinned. Every
     // resume entry (picker, --resume <id>) lands here via session/resume.ts.
     const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg), folderTag(process.cwd()));
+    // /export docx conversation — the plan startup, lane and journey cards are recorded on this session.
+    bindCliCardSession(session);
     // Round 6 item 4c — a resumed session keeps its skill for the first plain prompt.
     let resumeKeepsSkill = Boolean(opts?.resumedSession?.skill);
     // Round 7 item 8c — the footer shows a resumed session's spend at once.
@@ -1157,16 +1170,18 @@ export async function runRepl(opts) {
             // session audit record (who did what, where, under which approval, at
             // what cost) to a markdown file in cwd and print the path.
             if (trimmed === '/export' || trimmed.startsWith('/export ')) {
-                const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
-                const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+                const { parseExportArgs, runExportAuditCommand, EXPORT_REPL_USAGE } = await import('./commands/export-audit.js');
+                const { sub, filename, docxArgs } = parseExportArgs(trimmed.slice('/export'.length));
                 // Word export (2026-10-19): /export docx <file>.md, same body as `cspeach export`.
+                // 2026-10-23: no file → the last answer; `conversation` → the whole conversation.
+                // The Word package loads only here: /export audit never needs it.
                 if (sub === 'docx') {
-                    const { docxFileFromReplArgs, runExportDocxCommand } = await import('./commands/export-docx.js');
-                    await runExportDocxCommand({ file: docxFileFromReplArgs(trimmed.slice('/export'.length)), docx: true, system: session.sap_system, emit: (l) => chunkEmitter.emit('chunk', l + '\n') });
+                    const { runExportDocxRepl } = await import('./commands/export-conversation.js');
+                    await runExportDocxRepl({ args: docxArgs ?? '', session, ...(signedInAs ? { person: signedInAs } : {}), emit: (l) => chunkEmitter.emit('chunk', l + '\n') });
                     return;
                 }
                 if (sub !== 'audit') {
-                    chunkEmitter.emit('chunk', chalk.dim('\nUsage: /export audit [filename] · /export docx <file>.md\n'));
+                    chunkEmitter.emit('chunk', chalk.dim(`\n${EXPORT_REPL_USAGE}\n`));
                     return;
                 }
                 await runExportAuditCommand({
@@ -2051,6 +2066,8 @@ export async function runRepl(opts) {
                     // turns (their post-turn persist indexes messages from turn start).
                     autoCompact: planResume === null && planContinue === null,
                     delegateSkill: planPhaseDelegate,
+                    // /export docx conversation — a plan step or a queued step is CSPeach's words, not the person's.
+                    ...(await cliTurnOrigin(planResume, submitOpts?.queued ? line : null)),
                     // A4 — undefined on every non-plan turn (and when tiering is off).
                     modelOverride: planModelOverride,
                     // Task 9 — a tier-down, never the session role (proxy must not enforce it).
@@ -3026,6 +3043,8 @@ export async function runRepl(opts) {
     // Task 13 — classic in-run hop flag: set by the loop-top consumer from planHops.take().
     let classicPlanHop = false;
     let classicLineBy = 'person';
+    /** The command CSPeach queued for this line (null when the person typed it). */
+    let classicQueuedCmd = null;
     while (true) {
         // Re-attach the bare-Esc detector every iteration. Inquirer prompts
         // (slash-picker, approval, ask_question, safety-confirm) remove
@@ -3042,6 +3061,7 @@ export async function runRepl(opts) {
         const classicQueued = pendingDispatchAccessor.take();
         // Task 3 — who started this line: the CSPeach source that queued it, else the person.
         classicLineBy = classicQueued?.origin?.by ?? 'person';
+        classicQueuedCmd = classicQueued?.origin ? classicQueued.cmd : null;
         if (classicQueued) {
             const dispatchedCmd = classicQueued.cmd;
             // No context clear here: beginPlanPhaseContext (plan-boundary.ts,
@@ -3197,16 +3217,18 @@ export async function runRepl(opts) {
         // Task 4 (ux-wave3) — classic-mode /export audit [filename]. Mirrors the
         // Ink handler: build the signable audit record, write it to cwd, print path.
         if (trimmed === '/export' || trimmed.startsWith('/export ')) {
-            const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
-            const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+            const { parseExportArgs, runExportAuditCommand, EXPORT_REPL_USAGE } = await import('./commands/export-audit.js');
+            const { sub, filename, docxArgs } = parseExportArgs(trimmed.slice('/export'.length));
             // Word export (2026-10-19): /export docx <file>.md, same body as `cspeach export`.
+            // 2026-10-23: no file → the last answer; `conversation` → the whole conversation.
+            // The Word package loads only here: /export audit never needs it.
             if (sub === 'docx') {
-                const { docxFileFromReplArgs, runExportDocxCommand } = await import('./commands/export-docx.js');
-                await runExportDocxCommand({ file: docxFileFromReplArgs(trimmed.slice('/export'.length)), docx: true, system: session.sap_system, emit: (l) => console.log(l) });
+                const { runExportDocxRepl } = await import('./commands/export-conversation.js');
+                await runExportDocxRepl({ args: docxArgs ?? '', session, ...(signedInAs ? { person: signedInAs } : {}), emit: (l) => console.log(l) });
                 continue;
             }
             if (sub !== 'audit') {
-                console.log(chalk.dim('Usage: /export audit [filename] · /export docx <file>.md'));
+                console.log(chalk.dim(EXPORT_REPL_USAGE));
                 continue;
             }
             await runExportAuditCommand({
@@ -4133,6 +4155,8 @@ export async function runRepl(opts) {
                 // turns (their post-turn persist indexes messages from turn start).
                 autoCompact: planResume === null && planContinue === null,
                 delegateSkill: planPhaseDelegate,
+                // /export docx conversation — a plan step or a queued step is CSPeach's words, not the person's.
+                ...(await cliTurnOrigin(planResume, classicQueuedCmd)),
                 // A4 — undefined on every non-plan turn (and when tiering is off).
                 modelOverride: planModelOverride,
                 // Task 9 — a tier-down, never the session role (proxy must not enforce it).

package/dist/session/cli-record.js

@@ -0,0 +1,165 @@
+// cspeach-cli/src/session/cli-record.ts
+//
+// /export docx conversation, fix round 1 (2026-10-23). Two small records kept
+// on the session for the conversation export, NEVER sent to the model:
+//
+// - cli_messages: which user-role messages CSPeach wrote itself (a plan step
+//   prompt, the output-limit continuation, the watchdog note, a /compact or
+//   plan-boundary summary, a queued next step, a mid-turn steer). Each entry is
+//   the sha of the message content, not an index: compaction drops and moves
+//   messages, a content hash still finds the same message. The messages
+//   themselves are untouched, so every model request stays byte-identical.
+// - cli_cards: the CLI's own cards that matter for a change ticket (the plan
+//   gate "Build this now?", the plan startup "Continue", the lane card, the
+//   journey cards), anchored by turn_seq. Never the save or Word cards.
+//
+// Both are optional session fields. A session file is JSON.parse'd and written
+// whole (store.ts), so an older CLI that resumes the file keeps them as they are.
+import crypto from 'node:crypto';
+export const CLI_RECORD_CAP = 500;
+export const CONTINUE_LINE = 'CSPeach asked the model to continue a long answer.';
+export const WATCHDOG_LINE = 'CSPeach asked the model to wrap up a long turn.';
+export const COMPACT_LINE = 'Earlier turns were summarised to keep the session small.';
+export const PLAN_BOUNDARY_LINE = 'CSPeach summarised the earlier plan steps.';
+function shaOf(content) {
+    return crypto.createHash('sha256').update(typeof content === 'string' ? content : JSON.stringify(content ?? null)).digest('hex').slice(0, 32);
+}
+function capped(list) {
+    return list.length > CLI_RECORD_CAP ? list.slice(list.length - CLI_RECORD_CAP) : list;
+}
+/** Note that CSPeach wrote this user-role message. Never throws. */
+export function markCliMessage(session, content, kind, line) {
+    if (!session)
+        return;
+    try {
+        const s = session;
+        s.cli_messages = capped([...(s.cli_messages ?? []), { sha: shaOf(content), kind, line }]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/**
+ * Fixed-shape CLI texts, for sessions written before the record existed (or
+ * a mark the cap dropped). Prefixes only; the bodies are CSPeach's own words.
+ */
+const KNOWN_PREFIXES = [
+    { prefix: 'Resume execution of the project plan', kind: 'plan-step', line: 'CSPeach ran the next plan step.' },
+    { prefix: 'Your previous response was cut off at the output-token limit.', kind: 'continue', line: CONTINUE_LINE },
+    { prefix: '[CSPeach watchdog]', kind: 'watchdog', line: WATCHDOG_LINE },
+    { prefix: '[Context summary auto-generated', kind: 'compact', line: COMPACT_LINE },
+    { prefix: '[Summary of the earlier steps of this plan', kind: 'plan-boundary', line: PLAN_BOUNDARY_LINE },
+];
+function prefixMark(message) {
+    const text = typeof message.content === 'string' ? message.content
+        : Array.isArray(message.content) ? message.content.filter((b) => b?.type === 'text').map((b) => String(b.text ?? '')).join('\n') : '';
+    const t = text.trimStart();
+    const known = KNOWN_PREFIXES.find((k) => t.startsWith(k.prefix));
+    return known ? { sha: '', kind: known.kind, line: known.line } : undefined;
+}
+/**
+ * The mark of each message (undefined for the developer's own words), in
+ * message order. Fix round 2 (m-8): each mark is used once, in order — a
+ * message takes the first unused mark at or after the last one used that has
+ * its sha. So a command the developer retypes after CSPeach queued it, or a
+ * typed "continue" equal to an earlier steer, stays the developer's: that mark
+ * is already used. Marks of messages a compaction dropped are simply passed
+ * over. The prefix fallback is only for sessions with no records at all.
+ */
+export function resolveCliMarks(session, messages) {
+    const marks = session?.cli_messages;
+    if (!marks || marks.length === 0)
+        return messages.map((m) => (m.role === 'user' ? prefixMark(m) : undefined));
+    // Final-review fix (I-1): used once, any order. Look from the last mark used
+    // on; when nothing matches there, look again from the start (a file an older
+    // CLI compacted has the summary's mark last). A used mark is never reused.
+    const used = new Set();
+    let next = 0;
+    return messages.map((m) => {
+        if (m.role !== 'user')
+            return undefined;
+        const sha = shaOf(m.content);
+        const at = (from, to) => {
+            for (let j = from; j < to; j++)
+                if (!used.has(j) && marks[j].sha === sha)
+                    return j;
+            return -1;
+        };
+        let j = at(next, marks.length);
+        if (j < 0)
+            j = at(0, Math.min(next, marks.length));
+        if (j < 0)
+            return undefined;
+        used.add(j);
+        next = j + 1;
+        return marks[j];
+    });
+}
+/**
+ * Final-review fix (I-1): after a compaction keeps `kept` (the tail of the old
+ * messages, from index `keepFrom`) behind a new summary message, rebuild the
+ * record in message order: the summary's mark first, then the marks of the
+ * kept messages (recomputed from their content, so a mark found by the prefix
+ * fallback in an older file becomes a real one). Marks of dropped messages go.
+ */
+export function rebuildCliMarksAfterCompact(session, oldMessages, keepFrom, summaryContent, summary) {
+    try {
+        const resolved = resolveCliMarks(session, oldMessages);
+        const kept = [];
+        for (let i = keepFrom; i < oldMessages.length; i++) {
+            const m = resolved[i];
+            if (m)
+                kept.push({ sha: shaOf(oldMessages[i].content), kind: m.kind, line: m.line });
+        }
+        session.cli_messages = capped([{ sha: shaOf(summaryContent), kind: summary.kind, line: summary.line }, ...kept]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/** A turn of its own (the developer's prompt, a plan step, a queued step) vs. a message inside a turn. */
+export function startsTurn(mark) {
+    return !mark || mark.kind === 'plan-step' || mark.kind === 'queued';
+}
+/* ── cards ────────────────────────────────────────────────────────────── */
+let bound = null;
+/** The REPL (and each top-level turn) binds the session the cards belong to. */
+export function bindCliCardSession(session) { bound = session; }
+/**
+ * The card ids the card slot records for the export: plan startup, lane,
+ * journey. Never save or Word cards. "Build this now?" (app-start-build) is
+ * recorded by afterPlanSave itself, which knows the plan file and whether the
+ * object-list approval was installed (fix round 2, N-1).
+ */
+export function isRecordedCard(id) {
+    return id === 'plan-continue' || id === 'app-lane' || id === 'app-lane-runtime' || id.startsWith('journey-');
+}
+/** Record one card on the bound session (or the one given), with the time. Never throws. */
+export function recordCliCard(card, session = bound) {
+    if (!session)
+        return;
+    try {
+        const s = session;
+        const entry = { turn_seq: s.turn_seq ?? 0, at: new Date().toISOString(), ...card };
+        s.cli_cards = capped([...(s.cli_cards ?? []), entry]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/* ── once-per-object document offers ──────────────────────────────────── */
+/**
+ * Per session (in memory): the (skill, object) keys the newer document skills
+ * already offered "Save…?" for. Kept here, beside the records, so /new can
+ * clear it (final-review m-4).
+ */
+const documentOffers = new WeakMap();
+export function documentOffersFor(session) {
+    let s = documentOffers.get(session);
+    if (!s) {
+        s = new Set();
+        documentOffers.set(session, s);
+    }
+    return s;
+}
+/** /new: the once-per-object offers and the records of the cleared conversation go too. */
+export function clearConversationRecords(session) {
+    documentOffers.delete(session);
+    const s = session;
+    delete s.cli_messages;
+    delete s.cli_cards;
+}

package/dist/session/fresh-start.js

@@ -1,3 +1,4 @@
+import { clearConversationRecords } from './cli-record.js';
 export function startFreshConversation(session) {
     session.messages = [];
     session.turnInterrupted = false;
@@ -6,6 +7,9 @@ export function startFreshConversation(session) {
     delete session.lastAutoCompactTurn;
     // An open plan step does not survive: "continue" must not resume it.
     session.plan_in_flight = null;
+    // Word export (final-review m-4): the once-per-object save offers and the
+    // export records describe the cleared conversation; they go with it.
+    clearConversationRecords(session);
 }
 /** The one line /new prints. */
 export function freshStartText(lane) {

package/dist/ui/card-slot.js

@@ -9,6 +9,7 @@
 import { EventEmitter } from 'node:events';
 import { suspendActiveSpinner } from '../renderer/tool-widget.js';
 import { turnStatusEmitter } from './turn-status-emitter.js';
+import { isRecordedCard, recordCliCard } from '../session/cli-record.js';
 /**
  * Claim exclusive input focus for the duration of `fn`: pause the in-place
  * tool spinner and freeze the ticking status row so only the card repaints.
@@ -81,9 +82,25 @@ class CardSlotEmitter extends EventEmitter {
         if (this.listenerCount('confirm') === 0) {
             return Promise.resolve({ value: null, cancelled: true });
         }
-        return withFocusClaim(() => new Promise((resolve) => {
+        const shown = withFocusClaim(() => new Promise((resolve) => {
             this.emit('confirm', { ...req, resolve });
         }));
+        // /export docx conversation (2026-10-23): the plan gate, plan startup, lane
+        // and journey cards are kept on the session for the conversation export.
+        // Never the save or Word cards. Nothing here reaches the model.
+        if (!isRecordedCard(req.id))
+            return shown;
+        return shown.then((res) => {
+            const picked = res.value == null ? undefined : req.choices.find((c) => c.value === res.value);
+            recordCliCard({
+                question: req.title,
+                options: req.choices.map((c) => c.label),
+                ...(req.facts?.length ? { facts: [...req.facts] } : {}),
+                answer: picked?.label ?? (res.value == null ? 'Cancelled' : String(res.value)),
+                by: 'user',
+            });
+            return res;
+        });
     }
     on(event, listener) {
         return super.on(event, listener);