@cspeach/cli 1.1.50 → 1.1.52

package/dist/repl.js

@@ -30,6 +30,7 @@ import { createDispatchSlot, queuedStepView } from './session/queued-step.js';
 import { continueSkillFor } from './repl/continue-skill.js';
 import { applyResumedSkill } from './router/resume-routing.js';
 import { ACK_PHRASES, wantsContinuation, isConversationalAck, decideLane, turnStatusLabel, applyLaneTools, chatFallbackOrigin } from './repl/chat-lane.js';
+import { inlineActive, inlineServed, isChatLaneProcess } from './repl/inline-mode.js';
 import { CHAT_SKILL } from './agent/chat-prompt.js';
 import { setAssistantStyle } from './agent/style-state.js';
 import { setAssistantLevel } from './agent/level-state.js';
@@ -45,7 +46,7 @@ import { startSkillsCacheWarmup } from './skills/source-authed.js';
 import { formatLoginBanner, signInFragment } from './ui/login-banner.js';
 import { printStartupBanner, printKeytarFallbackBanner, keychainFallbackNotice } from './renderer/banners.js';
 import { paint } from './renderer/theme.js';
-import { steeringEchoLine, classifyMidTurnLine, midTurnSlashHint } from './renderer/steering-echo.js';
+import { classifyMidTurnLine, midTurnSlashHint } from './renderer/steering-echo.js';
 import { runAddSapWizard } from './sap/onboarding.js';
 import { getConnection } from './sap/connection-manager.js';
 import { unreachableCode, unreachableMessage } from './sap/unreachable.js';
@@ -154,6 +155,9 @@ import { getEffectiveWriteMode, runModeCommand } from './repl/mode-cycle.js';
 import { maybeExpandNumberSelection, lastAssistantText } from './repl/numbered-menu.js';
 import { attachEarlyLineBuffer, noopEarlyLineBuffer } from './repl/early-line-buffer.js';
 import { createRestoreGuard } from './repl/restore-guard.js';
+import { createLeftoverRunner, takeUnsentReport, parseSubmitted } from './repl/leftover.js';
+import { createTurnStop } from './repl/turn-stop.js';
+import { requestQueueToBox } from './ui/queue-box-emitter.js';
 import { gracefulExit } from './lib/graceful-exit.js';
 import { endSapSessionAfterTurn } from './sap/session-end.js';
 import { snapshotTurnStart, pushPostTurnStatus, seedFooterSpend } from './repl/post-turn-status.js';
@@ -208,6 +212,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 +808,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.
@@ -1066,13 +1083,47 @@ export async function runRepl(opts) {
                 : pendingCancelLine(phase, exiting, queuedWorkLabel(pendingDispatchAccessor.get()));
             chunkEmitter.emit('chunk', '\n' + formatInfo(line));
         };
+        // LT-15 Feature 4 — messages still waiting when a dispatch ends: run them
+        // as the next turn (normal end), put them back in the box (Ctrl+C, an
+        // error), let a queued hop read them first, or report them at exit.
+        // Flags are per dispatch: set below, read + reset by settle() in
+        // handleSubmit's finally and at a restore's end (plan review I4).
+        const leftover = createLeftoverRunner({
+            isBusy: () => turnStatusEmitter.isBusy(),
+            isDone: () => done,
+            // F4 — prose: never parsed as a slash command or @-shortcut; it goes
+            // through routing like a fresh prompt (review M5), as the person's turn.
+            submit: (text) => { void handleSubmit(text, { prose: true }); },
+            toBox: () => { requestQueueToBox(); },
+            print: (line) => chunkEmitter.emit('chunk', '\n' + line),
+            schedule: (fn) => { setImmediate(fn); },
+        });
+        // LT-15 Task 5b — how this dispatch was stopped (Esc brake or Ctrl+C).
+        // Per dispatch: read by autoDispatch (nothing queued starts after a stop)
+        // and by leftover.settle, reset right after that settle and at a
+        // restore's end (plan review I4). The brake reuses Ctrl+C's own abort and
+        // pending cancel and never touches interruptCount (review C1).
+        const turnStop = createTurnStop({
+            turnActive: () => currentTurnAbort !== null,
+            busy: () => turnStatusEmitter.isBusy(),
+            restoreActive: () => restoreGuard.active,
+            phase: () => cancelPhase(),
+            canChain: () => canChainNow(),
+            exitRequested: () => exitAfterTurn,
+            abortTurn: () => { currentTurnAbort?.abort(); },
+            cancelPending: () => { announcePendingCancel(false); },
+            print: (line) => chunkEmitter.emit('chunk', '\n' + formatInfo(line)),
+        });
         /** Auto-dispatch of the next plan phase, unless a post-turn cancel stopped it. */
         // Task 13 fix round — `planHop` travels WITH the command into handleSubmit,
         // so a refused submit can never leave a stale hop mark behind.
         const autoDispatch = (cmd, planHop = false, queued = null) => {
             // Round 4 item 9b — the exit is already under way: start nothing new.
             // Final review B-I2 — `/exit` typed mid-turn (exitAfterTurn) stops it too.
-            const decision = autoDispatchDecision({ done, exitRequested: exitAfterTurn, cancelPending: pendingCancel.pending }, cmd);
+            // LT-15 Task 5b (D4, 5a re-review) — nothing queued starts after a stop
+            // of this dispatch (Esc or Ctrl+C); the D11 chat fallback still re-runs
+            // the person's own message (review M6).
+            const decision = autoDispatchDecision({ done, exitRequested: exitAfterTurn, cancelPending: pendingCancel.pending, stopped: turnStop.stopped, chatFallback: queued?.by === 'chat_fallback' }, cmd);
             if (decision.kind === 'skip')
                 return;
             if (decision.kind === 'not-started') {
@@ -1085,6 +1136,8 @@ export async function runRepl(opts) {
             const notice = queued ? null : autoRoutedNotice(cmd);
             if (notice)
                 chunkEmitter.emit('chunk', formatInfo(notice));
+            // LT-15 D3 — the hop goes first; a waiting message is read at its round 0.
+            leftover.noteDispatchScheduled();
             setImmediate(() => { void handleSubmit(cmd, { planHop, queued }); });
         };
         // BUG-2b — the actual dispatch. Wrapped by handleSubmit (below) which
@@ -1095,6 +1148,9 @@ export async function runRepl(opts) {
             const trimmed = line.trim();
             if (!trimmed)
                 return;
+            // LT-15 F4 — a replayed waiting message is prose, also when the D11
+            // chat fallback re-runs it (the flag rides on the fallback origin).
+            const prose = submitOpts?.prose === true || submitOpts?.queued?.prose === true;
             // Round 6 review I2 — the resumed skill is offered to the FIRST submit
             // only (slash commands included), then cleared.
             const resumedSkill = resumeKeepsSkill ? session.skill ?? null : null;
@@ -1103,7 +1159,10 @@ export async function runRepl(opts) {
             // the Footer has already persisted this submission (flattened), so
             // the consecutive-dup guard makes this a no-op instead of the old
             // double append.
-            appendHistoryEntry(trimmed);
+            // LT-15 F4 — a replayed waiting message is already in history (the
+            // Footer stored each one when it was typed).
+            if (!prose)
+                appendHistoryEntry(trimmed);
             // Phase A** (2026-05-16) — echo the user's prompt into Body so it
             // appears in the conversation history. Plus a dim divider above
             // the echo so consecutive turns have a clear visual break (closes
@@ -1157,16 +1216,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({
@@ -1347,7 +1408,7 @@ export async function runRepl(opts) {
                         provider,
                         userMessage: rr.prompt,
                         skill: rr.skill,
-                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !!process.stdin.isTTY, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !!process.stdin.isTTY), turnBy: lastTurnBy },
                         chunkEmitter,
                         pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                         autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
@@ -1356,6 +1417,11 @@ export async function runRepl(opts) {
                     session,
                     print: (line) => chunkEmitter.emit('chunk', line + '\n'),
                     signal: rerouteAbort.signal,
+                    // LT-15 review I5 — an error end puts waiting text back in the box.
+                    onError: () => { if (!rerouteAbort.signal.aborted)
+                        leftover.noteError(); },
+                    // LT-15 Task 5b — an Esc brake prints one dim line, not the block.
+                    stopLine: () => (turnStop.brakedOnly ? formatInfo(turnStop.endLine()).trimEnd() : null),
                     onFinally: () => {
                         turnStatusEmitter.stop();
                         currentTurnAbort = null;
@@ -1378,6 +1444,9 @@ export async function runRepl(opts) {
                 todoEmitter.emit('update', []);
                 clearAppFlow(session); // Task 7 — /new ends an /abap-app flow
                 clearJourneyFlow(session); // Task 3 — and a clean-core journey
+                // LT-15 Task 4 — a message still waiting belongs to the old
+                // conversation: back into the box (or reported), never carried over.
+                leftover.toBoxOrReport();
                 // 2026-10-22 — and the conversation history: the next prompt sends none of it.
                 startFreshConversation(session);
                 idleKeepalive.disarm(); // no idle cache ping for the old history
@@ -1450,7 +1519,9 @@ export async function runRepl(opts) {
             // an item in a 2+-item list in the LAST assistant message.
             let effectiveInput = trimmed;
             {
-                const expansion = maybeExpandNumberSelection(trimmed, lastAssistantText(session.messages));
+                // LT-15 Task 4 fix round 1 — never for a replayed waiting message: a
+                // "2" typed mid-turn did not answer the menu of the turn that just ended.
+                const expansion = prose ? null : maybeExpandNumberSelection(trimmed, lastAssistantText(session.messages));
                 if (expansion) {
                     chunkEmitter.emit('chunk', chalk.dim(`${expansion.echo}\n`));
                     effectiveInput = expansion.text;
@@ -1475,7 +1546,9 @@ export async function runRepl(opts) {
                 return;
             }
             effectiveInput = door.input;
-            const parsed = parseShortcut(effectiveInput);
+            // LT-15 F4 — a replayed waiting message is prose: never a slash command
+            // or an @-shortcut (`/sap/bc/adt/x is slow` reaches the model as text).
+            const parsed = parseSubmitted(effectiveInput, prose);
             // D35 (2026-06-11) — explicit slash naming a skill that isn't in the
             // catalog: print the notice ("did you mean" / builtin-with-args) and
             // end the turn. Slash input must NEVER fall through to the classifier
@@ -1596,7 +1669,7 @@ export async function runRepl(opts) {
                                 sap_system: selectedAlias,
                                 last_skill: session.last_skill ?? null,
                                 last_object: extractedObject ?? session.last_object ?? null,
-                            }, { signal: routingCtl.signal });
+                            }, { signal: routingCtl.signal, prose });
                         }
                         catch (err) {
                             if (!routingCtl.signal.aborted) {
@@ -2041,7 +2114,8 @@ export async function runRepl(opts) {
                     provider,
                     userMessage: prompt,
                     skill: skill,
-                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    // Stage 1A — inline is decided here, at every submit, from today's inputs (never cached).
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !!process.stdin.isTTY, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !!process.stdin.isTTY), turnBy: lastTurnBy },
                     chunkEmitter,
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     explicitSlash: parsed.skill !== undefined, // Task 7 R11 — typed or queued slash command
@@ -2051,6 +2125,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).
@@ -2117,7 +2193,7 @@ export async function runRepl(opts) {
                     // never throw ChatUnavailableError again.
                     laneSetting = 'skills';
                     sapStateStore.update({ chatLane: false });
-                    pendingDispatchAccessor.set(trimmed, chatFallbackOrigin());
+                    pendingDispatchAccessor.set(trimmed, chatFallbackOrigin(prose));
                 }
                 else {
                     // 2026-09-24 — print the turn-error block INTO the conversation (it
@@ -2127,13 +2203,25 @@ export async function runRepl(opts) {
                     // "type continue" (the partial turn is already saved).
                     const { renderTurnError } = await import('./agent/turn-error-ux.js');
                     turnCancelledByUser = currentTurnAbort?.signal.aborted ?? false;
-                    await renderTurnError({
-                        err,
-                        session,
-                        userInterrupted: turnCancelledByUser,
-                        inSession: true,
-                        print: (line) => chunkEmitter.emit('chunk', line + '\n'),
-                    });
+                    // LT-15 review I5 — an error end (not a stop): waiting text goes back
+                    // into the box, nothing runs by itself.
+                    if (!turnCancelledByUser)
+                        leftover.noteError();
+                    if (turnCancelledByUser && turnStop.brakedOnly) {
+                        // LT-15 Task 5b — an Esc brake: one dim line in place of the
+                        // "type continue" block. The loop already saved the turn as
+                        // interrupted, and a journey stays paused.
+                        chunkEmitter.emit('chunk', '\n' + formatInfo(turnStop.endLine()));
+                    }
+                    else {
+                        await renderTurnError({
+                            err,
+                            session,
+                            userInterrupted: turnCancelledByUser,
+                            inSession: true,
+                            print: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                        });
+                    }
                 }
             }
             finally {
@@ -2426,21 +2514,23 @@ export async function runRepl(opts) {
                     chunkEmitter.emit('chunk', midTurnSlashHint(kind.command));
                     return;
                 }
-                if (t.length > 0) {
+                // LT-15 Feature 1 (D5) — no scrollback receipt; the App's queue row shows it.
+                if (t.length > 0)
                     enqueueSteering(t);
-                    chunkEmitter.emit('chunk', steeringEchoLine(t));
-                }
                 return;
             }
             idleKeepalive.disarm(); // Task 15 — a submit ends the idle period
             turnStatusEmitter.reserve();
             postTurn = false;
             postTurnMayChain = false;
+            // LT-15 review I5 — a dispatch that threw ended by an error.
+            let threw = true;
             try {
                 // Round 4 item 9b — the exit path waits (capped) for this to finish.
                 const run = dispatchSubmit(line, submitOpts);
                 dispatchTail = run;
                 await run;
+                threw = false;
             }
             finally {
                 turnStatusEmitter.release();
@@ -2462,6 +2552,14 @@ export async function runRepl(opts) {
                 // the submit ended in an exit (merge: UI round-3 /exit mid-turn).
                 if (!done)
                     idleKeepalive.armAfterTurn(session);
+                // LT-15 Feature 4 — after release(): messages still waiting run as the
+                // next turn (on the next tick, drained there), go back into the box,
+                // wait for a queued hop, or are left for the exit report.
+                if (threw)
+                    leftover.noteError();
+                leftover.settle({ exitRequested: exitAfterTurn, braked: turnStop.braked });
+                // LT-15 Task 5b (I4) — the stop belongs to this dispatch only.
+                turnStop.reset();
             }
         };
         // Fix round 3 (item 5) — `/exit` / `/quit` typed while a turn runs:
@@ -2478,6 +2576,9 @@ export async function runRepl(opts) {
                 cancelAnnouncedPhase = null;
                 pendingCancel.clear();
                 interruptCount = 0;
+                // LT-15 Feature 4 — a restore's end decides like a normal turn end.
+                leftover.settle({ exitRequested: exitAfterTurn, braked: turnStop.braked });
+                turnStop.reset();
             },
             exit: () => { done = true; if (resolveDone)
                 resolveDone(); },
@@ -2515,6 +2616,10 @@ export async function runRepl(opts) {
         let idleInterruptAt = 0;
         const onInterrupt = () => {
             const now = Date.now();
+            // LT-15 D1 — Ctrl+C during a dispatch: waiting messages go back into the
+            // box at this dispatch's end; nothing runs by itself.
+            if (turnStatusEmitter.isBusy())
+                leftover.noteCtrlC();
             const action = decideInterrupt({
                 turnActive: currentTurnAbort !== null,
                 // Review I3 — routing / prep in flight without a controller yet is
@@ -2528,18 +2633,30 @@ export async function runRepl(opts) {
             });
             if (action === 'abort-turn') {
                 interruptCount++;
-                chunkEmitter.emit('chunk', '\n' + formatInfo('Stopping the turn · saving the work done so far'));
+                turnStop.noteCtrlCStop(); // LT-15 Task 5b — nothing queued starts after it
+                // After an Esc the stop line is already on screen: not repeated (C1).
+                if (!turnStop.braked)
+                    chunkEmitter.emit('chunk', '\n' + formatInfo('Stopping the turn · saving the work done so far'));
                 currentTurnAbort.abort();
+                return 'stopped'; // LT-15 D1 — App puts the waiting text back in the box now
             }
             else if (action === 'cancel-pending') {
                 interruptCount++;
+                turnStop.noteCtrlCStop();
                 announcePendingCancel(false);
+                return 'stopped';
             }
             else if (action === 'force-exit') {
                 // Second Ctrl+C during the same turn — give up and exit.
                 chunkEmitter.emit('chunk', '\n' + formatInfo('Exiting · second Ctrl+C'));
                 unmount();
                 process.stdout.write('\x1b[?25h'); // restore cursor
+                // LT-15 Feature 4 — say how many waiting messages were never sent.
+                {
+                    const unsent = takeUnsentReport();
+                    if (unsent)
+                        console.log(unsent.trimEnd());
+                }
                 printGoodbye(session);
                 // Final review B M-2 — through gracefulExit (fetch drain, capped).
                 // Re-review item 3 — mark the session done first, so nothing queued
@@ -2559,6 +2676,18 @@ export async function runRepl(opts) {
                     resolveDone();
             }
         };
+        // LT-15 Task 5b — Esc while working (the App calls this only while busy
+        // and when no card, held draft or Ctrl+R search owns the Esc). The brake
+        // decides with decideEscape and reuses Ctrl+C's own stop.
+        const onBrake = (ui) => {
+            turnStop.press(ui);
+        };
+        // LT-15 Revision 2 — Esc / [c] on the approval card (or Esc / Cancel on
+        // the plan gate card) is the same safe stop as the Esc brake. The card
+        // still answers cancel-turn, so nothing from it is written or minted.
+        const onCardStop = () => {
+            turnStop.stopFromCard();
+        };
         // Wave1 live-fix (Bug 2) — bracketed paste for the Ink path. Windows
         // Terminal delivers pasted newlines as `\r`, and a `\r`-only chunk
         // parses as key.return (ink parse-keypress.js:145-148) → every pasted
@@ -2623,6 +2752,8 @@ export async function runRepl(opts) {
             sapAlias: selectedAlias,
             onInterrupt,
             onExitRequest,
+            onBrake,
+            onCardStop,
         }), {
             // Bug 2 (wave1 live-fix) — Ink reads from the paste guard, not
             // process.stdin directly. The guard satisfies Ink's full stdin
@@ -2701,6 +2832,13 @@ export async function runRepl(opts) {
         if (exitTail === 'timeout') {
             console.log(formatAttention({ text: 'Post-turn work did not finish', fact: 'the session file may be incomplete' }).trimEnd());
         }
+        // LT-15 Feature 4 — `/exit` (or the idle exit) with messages still waiting:
+        // they are not sent; say how many.
+        {
+            const unsent = takeUnsentReport();
+            if (unsent)
+                console.log(unsent.trimEnd());
+        }
         printGoodbye(session);
         return 0;
     }
@@ -3026,6 +3164,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 +3182,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 +3338,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({
@@ -3382,7 +3525,7 @@ export async function runRepl(opts) {
                     provider,
                     userMessage: rr.prompt,
                     skill: rr.skill,
-                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !pipedStdin, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !pipedStdin), turnBy: lastTurnBy },
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
                 }),
@@ -4124,7 +4267,8 @@ export async function runRepl(opts) {
                 provider,
                 userMessage: prompt,
                 skill: skill,
-                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                // Stage 1A — inline is decided here, at every submit, from today's inputs (never cached).
+                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !pipedStdin, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !pipedStdin), turnBy: lastTurnBy },
                 pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                 explicitSlash: parsed.skill !== undefined, // Task 7 R11 — typed or queued slash command
                 signal: turnAbort.signal,
@@ -4133,6 +4277,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/router/classifier.js

@@ -157,7 +157,7 @@ export async function classifyPrompt(prompt, context, opts = {}) {
     // before classification; this guard is the backstop that turns any
     // future regression into a loud error instead of a silent misroute.
     // Fires BEFORE config/key loading so no network call is ever made.
-    if (prompt.trimStart().startsWith('/')) {
+    if (!opts.prose && prompt.trimStart().startsWith('/')) {
         throw new Error('slash command reached the classifier — explicit /commands must be routed before classification (CLI bug, please report)');
     }
     const cfg = await loadConfig();

package/dist/sap/reachability-state.js

@@ -7,6 +7,13 @@ let unreachable = null;
 const CODE_RE = /\b(ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|ECONNRESET|EAI_AGAIN)\b/;
 export const SAP_UNREACHABLE_DIRECTIVE = 'SAP is not reachable from this machine right now. Stop here: do not retry SAP tools and do not write the plan manifest. '
     + 'End the turn with one short sentence. CSPeach pauses the build and runs this step again when the network is back.';
+/**
+ * LT-14 (1A fix wave) — outside a plan step, the note that rides on a SAP
+ * tool error when SAP did not answer. Before, the model got the bare error
+ * and invented network advice for the person. No pause, no flag.
+ */
+export const SAP_UNREACHABLE_NOTE = 'SAP did not answer from this machine. Do not guess why or give the person network advice. '
+    + "After three such failures in a row, stop and ask; offer 'SAP is reachable again; try once more' and 'Stop for now; I'll pick up later'.";
 export function noteSapUnreachable(code) {
     unreachable = code;
 }

package/dist/sap/unreachable.js

@@ -26,6 +26,6 @@ export function unreachableMessage(alias, host, port, code) {
     return (
     // 2026-10-04: never assume a VPN — many users sit on the company network.
     `Can't reach SAP system ${alias} (${host}:${port}) from this machine — ${code}. ` +
-        'Check network access to the SAP system (company network or VPN), ' +
-        'or run with --no-sap for work that does not need SAP.');
+        'Check network access to the SAP system. ' +
+        'For work that does not need SAP, run with --no-sap.');
 }