@cspeach/cli 1.1.51 → 1.1.53

package/dist/repl/reroute-turn.js

@@ -13,7 +13,13 @@ export async function runRerouteTurn(p) {
         await p.run();
     }
     catch (err) {
-        await renderTurnError({ err, session: p.session, userInterrupted: p.signal?.aborted ?? false, inSession: true, print: p.print });
+        const stopped = p.signal?.aborted ?? false;
+        const line = stopped ? p.stopLine?.() ?? null : null;
+        if (line !== null)
+            p.print(line);
+        else
+            await renderTurnError({ err, session: p.session, userInterrupted: stopped, inSession: true, print: p.print });
+        p.onError?.();
     }
     finally {
         p.onFinally();

package/dist/repl/turn-stop.js

@@ -0,0 +1,64 @@
+/**
+ * LT-15 Task 5b — how the current dispatch was stopped (Ink REPL only;
+ * classic, headless and one-shot have no Esc brake).
+ *
+ * Per dispatch (plan review I4): set by the presses, read by autoDispatch
+ * (a queued hop / lane plan / switch is not started after ANY stop) and by
+ * the leftover runner's settle, then reset in handleSubmit's finally right
+ * after that settle, and at a restore's end. Never reset at controller
+ * creation, so a stale stop can never touch the next hop or turn.
+ *
+ * `press` is the Esc brake. It reuses what Ctrl+C already does — the SAME
+ * `currentTurnAbort.abort()` (deps.abortTurn) or, in the post-turn window,
+ * the SAME pending cancel (deps.cancelPending) — and never touches Ctrl+C's
+ * press count (review C1): after an Esc, one Ctrl+C is still Ctrl+C's FIRST
+ * press, never the force-exit.
+ */
+import { steeringSnapshot } from '../agent/steering-queue.js';
+import { decideEscape, brakeLine, brakeEndLine } from '../ui/interrupt.js';
+export function createTurnStop(deps) {
+    let braked = false;
+    let ctrlC = false;
+    const waiting = deps.waiting ?? (() => steeringSnapshot().length);
+    const decide = (ui) => decideEscape({
+        ...ui,
+        turnActive: deps.turnActive(),
+        busy: deps.busy(),
+        restoreActive: deps.restoreActive(),
+        phase: deps.phase(),
+        canChain: deps.canChain(),
+        alreadyStopped: braked || ctrlC || deps.exitRequested(),
+    });
+    const brake = () => {
+        braked = true;
+        deps.print(brakeLine(waiting() > 0));
+        deps.abortTurn();
+    };
+    return {
+        stopFromCard() {
+            // The card itself is the overlay that owned the key: decide as if
+            // nothing else were open. Only a running turn is stopped.
+            if (decide({ overlayOpen: false, bufferCount: 0, fuzzyOpen: false }) !== 'brake')
+                return 'none';
+            brake();
+            return 'brake';
+        },
+        press(ui) {
+            const action = decide(ui);
+            if (action === 'brake') {
+                brake();
+            }
+            else if (action === 'cancel-pending') {
+                braked = true;
+                deps.cancelPending();
+            }
+            return action;
+        },
+        noteCtrlCStop() { ctrlC = true; },
+        get braked() { return braked; },
+        get stopped() { return braked || ctrlC; },
+        get brakedOnly() { return braked && !ctrlC; },
+        endLine() { return brakeEndLine(waiting() > 0); },
+        reset() { braked = false; ctrlC = false; },
+    };
+}

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';
@@ -201,6 +205,7 @@ import './tools/project/team_findings.js';
 import './tools/project/team_estate.js';
 import './tools/project/rules_propose.js';
 import './tools/project/team_lane_move.js';
+import './tools/project/spec_answers_record.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
@@ -1079,13 +1084,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') {
@@ -1098,6 +1137,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
@@ -1108,6 +1149,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;
@@ -1116,7 +1160,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
@@ -1362,7 +1409,8 @@ 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 },
+                        ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                         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
@@ -1371,6 +1419,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;
@@ -1393,6 +1446,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
@@ -1465,7 +1521,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;
@@ -1490,7 +1548,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
@@ -1580,7 +1640,7 @@ export async function runRepl(opts) {
                 // Round 6 item 4c / review I2 — after a resume, a short follow-up
                 // ("continue", a number) stays in the session's skill; anything else
                 // is classified (applyResumedSkill below).
-                const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill });
+                const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill, lastChangeOptions: session.lastChangeOptions ?? null });
                 if (continuedSkill) {
                     chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'continuing', skill: continuedSkill }));
                     skill = continuedSkill;
@@ -1611,7 +1671,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) {
@@ -2056,7 +2116,9 @@ 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 },
+                    ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                     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
@@ -2134,7 +2196,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
@@ -2144,13 +2206,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 {
@@ -2276,6 +2350,8 @@ export async function runRepl(opts) {
                             tokensUsed: 0,
                             model: session.model,
                             emit: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                            ...(signedInAs ? { operator: signedInAs } : {}),
+                            sessionId: session.id,
                         });
                     }
                     else if (r.kind === 'none' && !(await import('./sap/reachability-state.js')).isSapUnreachableNoted()) {
@@ -2443,21 +2519,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();
@@ -2479,6 +2557,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:
@@ -2495,6 +2581,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(); },
@@ -2532,6 +2621,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
@@ -2545,18 +2638,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
@@ -2576,6 +2681,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
@@ -2640,6 +2757,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
@@ -2718,6 +2837,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;
     }
@@ -3404,7 +3530,8 @@ 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 },
+                    ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                     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
                 }),
@@ -3712,7 +3839,7 @@ export async function runRepl(opts) {
                 continue;
             }
             // Round 6 item 4c / review I2 — see the Ink path.
-            const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill });
+            const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill, lastChangeOptions: session.lastChangeOptions ?? null });
             if (continuedSkill) {
                 console.log(formatRoutingLine({ kind: 'continuing', skill: continuedSkill }).trimEnd());
                 skill = continuedSkill;
@@ -4146,7 +4273,9 @@ 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 },
+                ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                 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,
@@ -4340,6 +4469,8 @@ export async function runRepl(opts) {
                         tokensUsed: 0,
                         model: session.model,
                         emit: (line) => console.log(line),
+                        ...(signedInAs ? { operator: signedInAs } : {}),
+                        sessionId: session.id,
                     });
                 }
                 else if (r.kind === 'none' && !(await import('./sap/reachability-state.js')).isSapUnreachableNoted()) {

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.');
 }

package/dist/session/fresh-start.js

@@ -10,6 +10,10 @@ export function startFreshConversation(session) {
     // 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);
+    // Change options (1.1.53): the last document goes too; a level reply then routes as today.
+    session.lastChangeOptions = null;
+    // Task 16: a pending blocker-form note describes the cleared conversation.
+    delete session.blockerAnswersNote;
 }
 /** The one line /new prints. */
 export function freshStartText(lane) {

package/dist/session/queued-step.js

@@ -45,5 +45,7 @@ export function queuedStepView(origin) {
     if (!line)
         return { echo: false, line: null };
     // D11 — the chat-fallback line is dim; painted after shownUpTo flattened it.
-    return { echo: false, line: origin.by === 'chat_fallback' ? paint('dim', line) : line };
+    // LT-4 (1A fix wave, owner ruling): the hand-off arrow line is dim too, kept in scrollback.
+    const dim = origin.by === 'chat_fallback' || origin.by === 'hand_off';
+    return { echo: false, line: dim ? paint('dim', line) : line };
 }

package/dist/session/user-prompt.js

@@ -26,8 +26,19 @@ export function isUserPrompt(m) {
  * (`<session_context>` from the intent extractor / SAP system info,
  * `<project_context>` from CSPEACH_PROJECT_CONTEXT). The user never typed
  * them, so a prompt preview must never show them (fix round 3, item 2).
+ * Stage 1A (M5) — `<skill>`, the playbook block an inline turn appends. The
+ * order matters: `<session_context>` first, so the bare `<skill>` word in a
+ * `<playbook>` line goes with the block it sits in — `skill` stays last.
+ * Shared with the conversation export (commands/export-conversation.ts).
  */
-const INJECTED_CONTEXT_TAGS = ['session_context', 'project_context'];
+export const INJECTED_CONTEXT_TAGS = [
+    'session_context', 'project_context',
+    // The /export docx conversation list (main, 2026-10-23): one list for both readers.
+    'journey', 'lane_decision', 'system_switch', 'sap_system', 'sap_connection',
+    // Task 16 (F-M): the blocker form's note (it rides inside <session_context>).
+    'blocker_answers',
+    'skill',
+];
 /**
  * One-line preview of what the user typed: injected context blocks removed,
  * `<attached file="x">…</attached>` expansions shown as the original `@x`

package/dist/skills/manifest-client.js

@@ -4,6 +4,7 @@ import { sha512 } from '@noble/hashes/sha512';
 import { bytesToHex, concatBytes } from '@noble/hashes/utils';
 import { MANIFEST_PUBLIC_KEYS } from './signing-public-key.js';
 import { canonicalise } from './canonical.js';
+import { fetchWithConnectRetry } from '../util/connect-retry.js';
 // @noble/ed25519 v2 requires an ed25519 sha512 hook.
 ed.etc.sha512Sync = (...m) => sha512(concatBytes(...m));
 /**
@@ -39,7 +40,7 @@ export class ManifestClient {
     async fetchManifest() {
         let r;
         try {
-            r = await fetch(this.manifestUrl, { signal: AbortSignal.timeout(10_000) });
+            r = await fetchWithConnectRetry(this.manifestUrl, () => ({ signal: AbortSignal.timeout(10_000) }));
         }
         catch (e) {
             throw new ManifestUnavailableError(`manifest fetch failed (${this.manifestUrl}): ${e.message}`);
@@ -99,7 +100,7 @@ export class ManifestClient {
     async fetchSkillBody(name, bodyUrl, opts) {
         let r;
         try {
-            r = await fetch(bodyUrl, { signal: AbortSignal.timeout(10_000) });
+            r = await fetchWithConnectRetry(bodyUrl, () => ({ signal: AbortSignal.timeout(10_000) }));
         }
         catch (e) {
             throw new Error(`skill body fetch failed (${bodyUrl}): ${e.message}`);

package/dist/skills/preamble.js

@@ -52,8 +52,10 @@ take precedence if a skill's instruction conflicts with them.
   revise and re-submit.
 
 ## Transport discipline
-- All writes go into the active session transport. Do not ask the user
-  for a transport number per change.
+- All writes go into the session transport once one is set. Do not ask
+  the user for a transport number per change. When a create says a
+  transport is needed, ask the user once: a new session transport
+  (recommended) or one of the open requests for the package.
 - Never use \$TMP unless the user explicitly requests local-only work.
 
 ## Escalate, don't fail silently
@@ -70,6 +72,6 @@ take precedence if a skill's instruction conflicts with them.
 
 ## One skill per turn
 - If the user's request is better served by a different skill, call
-  switch_skill with a clear reason. Do not try to do the work of another
-  skill yourself.
+  dispatch_skill after the person has picked the command. Do not try to do
+  the work of another skill yourself.
 `;