@cspeach/cli 1.1.51 → 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';
@@ -1079,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') {
@@ -1098,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
@@ -1108,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;
@@ -1116,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
@@ -1362,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
@@ -1371,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;
@@ -1393,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
@@ -1465,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;
@@ -1490,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
@@ -1611,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) {
@@ -2056,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
@@ -2134,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
@@ -2144,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 {
@@ -2443,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();
@@ -2479,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:
@@ -2495,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(); },
@@ -2532,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
@@ -2545,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
@@ -2576,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
@@ -2640,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
@@ -2718,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;
     }
@@ -3404,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
                 }),
@@ -4146,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,

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/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,17 @@ 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',
+    '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.
 `;

package/dist/skills/source-authed.js

@@ -14,6 +14,7 @@ import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
 import { ManifestClient, DEFAULT_MANIFEST_URL, SkillIntegrityError, ManifestUnavailableError, } from './manifest-client.js';
 import { fileSkillsCache } from './skills-cache.js';
+import { fetchWithConnectRetry } from '../util/connect-retry.js';
 // Defined next to the client that throws it (Task 8 (a): typed, never string-matched).
 export { SkillIntegrityError };
 export class SkillNotInPlanError extends Error {
@@ -69,10 +70,10 @@ async function fetchSignedInBody(baseUrl, name, expectedSha, getBearer, doFetch)
         throw new SkillSignInError();
     let r;
     try {
-        r = await doFetch(`${baseUrl}/v1/skills/${encodeURIComponent(name)}`, {
+        r = await fetchWithConnectRetry(`${baseUrl}/v1/skills/${encodeURIComponent(name)}`, () => ({
             headers: { Authorization: `Bearer ${bearer}` },
             signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-        });
+        }), { fetchImpl: doFetch });
     }
     catch {
         throw new SkillsUnavailableError('could not reach CSPeach');

package/dist/tools/approval.js

@@ -6,6 +6,14 @@ import { isHeadless, shouldUseInk } from '../renderer/tty.js';
 import { effectiveRisk, riskResultFields, typeCode } from '../approvals/risk-floor.js';
 import { objectsWithSyntaxErrors } from './syntax-state.js';
 import { noteWriteTransport } from '../repl/current-transport.js';
+import { STOPPED_BEFORE_START_RESULT } from '../agent/repair-partial.js';
+/**
+ * LT-15 D6 (F6) — after a stop (Esc or Ctrl+C set the same turn abort) no new
+ * card opens and no approval id is minted. The shape dispatchTool returns for
+ * a tool that never started (the tool_use stays paired), with a text that says
+ * nothing ran.
+ */
+const stoppedBeforeCard = (ctx) => (ctx.signal?.aborted ? { content: STOPPED_BEFORE_START_RESULT, is_error: true } : null);
 /**
  * Round 8 item 6 — the footer showed "no transport" while the approved card
  * said "transport S4HK903731". An approval granted for an explicit transport
@@ -29,7 +37,7 @@ import { promptAdvisory } from '../approvals/advisory-prompt.js';
 import { markPlanGateApproved } from '../repl/rule8-detector.js';
 import { getEffectiveWriteMode } from '../repl/mode-cycle.js';
 import { getCurrentTransport } from '../repl/current-transport.js';
-import { displayTransport } from '../approvals/op-labels.js';
+import { displayTransport, knownTypeWord } from '../approvals/op-labels.js';
 import { canonicalApprovalObject as bareObjectName } from '../approvals/canonical.js';
 import { projectTransport, SEVERAL_REQUESTS_LABEL, transportForWrite, TRANSPORT_REQUEST } from '../register/project-transport.js';
 import { NOT_ON_THIS_RELEASE, approvalRefusedByProfile } from '../sap/profile-gate.js';
@@ -223,7 +231,8 @@ registerTool({
                     type: 'object',
                     properties: {
                         op: { type: 'string', enum: ['create', 'modify', 'delete', 'activate', 'release', 'run'] },
-                        object: { type: 'string' },
+                        // P-2 (1A fix wave): a group word ('DCLs') is not an object the plan grant can match.
+                        object: { type: 'string', description: "One real object name per row (comma-join several only in an activate row), never a group word such as 'DCLs'." },
                         type: { type: 'string' },
                         diff: { type: 'string', description: 'For a CREATE op this MUST be the exact, complete source that will be written — verbatim, character-for-character, NOT a description, summary, or paraphrase. It is shown to the developer in the approval box as the exact thing they are approving, so a one-line summary here means they approve a write they cannot inspect. For a MODIFY op, the real unified diff of the change (again verbatim, not a description).' },
                         package: { type: 'string', description: 'Target package (development class) for the object, if known — shown on the approval box' },
@@ -298,6 +307,10 @@ registerTool({
         // no role configured and no session override this is exactly
         // cfg.write_mode — byte-identical behavior.
         const role = cfg.sap[ctx.sapAlias]?.role;
+        // LT-15 D6 — stopped during the profile read above: no advisory card, no card.
+        const stopA = stoppedBeforeCard(ctx);
+        if (stopA)
+            return stopA;
         // Advisory-only short-circuit — never mint approval_ids.
         // The developer applies the change manually in ADT; the AI gets an
         // ai_directive telling it not to attempt any SAP write tools.
@@ -313,11 +326,17 @@ registerTool({
             return { content: JSON.stringify(releaseRefusal), is_error: true };
         // Task 8 (B11) — the request that already holds each modified object, before any card.
         await attachOwningTransport(args.changes ?? [], ctx);
+        // LT-15 D6 — stopped during the reads above: no card, no nag, no id minted
+        // (the plan-grant and auto-approve paths below mint without a card).
+        const stopB = stoppedBeforeCard(ctx);
+        if (stopB)
+            return stopB;
         let sapCfg = cfg.sap[ctx.sapAlias];
         const riskCtx = {
             sapAlias: ctx.sapAlias,
             autoApprovePolicy: sapCfg?.auto_approve ?? 'never',
             syntaxErrorObjects: objectsWithSyntaxErrors(),
+            typeWord: knownTypeWord, // LT-10: the syntax-errors reason names the kind of object
         };
         const changes = args.changes;
         const declared = args.risk;
@@ -421,6 +440,10 @@ registerTool({
             sapCfg = cfg.sap[ctx.sapAlias];
             riskCtx.autoApprovePolicy = sapCfg?.auto_approve ?? 'never';
         }
+        // LT-15 D6 (review M3) — stopped while the nag was up: no card after it, no id.
+        const stopC = stoppedBeforeCard(ctx);
+        if (stopC)
+            return stopC;
         // 1.1.31 (owner, 2026-10-07): a package or transport always gets a person's
         // yes. Live, auto_approve="low" let the model's own "low" create package
         // ZCC_FIX_PROOF and request S4HK903757 with no card. The plan-grant path
@@ -478,12 +501,14 @@ registerTool({
         // for one task" complaint. Review-each falls back to the per-change
         // gate. Cancel rejects the whole plan.
         //
-        // Task 9 (C8): only for more than one VISIBLE change — the same count the
-        // plan gate shows (an activate whose write is in the list is not a change
-        // a person sees). A modify + its activate on one class gets the
-        // per-change card only; the activate follows its approved write below.
+        // Task 9 (C8): only for more than one VISIBLE change (an activate whose
+        // write is in the list is not a change a person sees). A modify + its
+        // activate on one class gets the per-change card only; the activate
+        // follows its approved write below. LT-12: the plan gate's LIST also
+        // hides a modify that a create of the same object covers (planRows), so
+        // it may show fewer rows than this count; this count is unchanged.
         let skipPerChangeGates = false;
-        // Raw keys on purpose: the same collapse (and count) the plan gate displays.
+        // Raw keys on purpose: activates collapsed, nothing else.
         const visibleCount = collapseImplicitActivates(changes).length;
         if (visibleCount > 1) {
             const mode = await renderPlanGate(args.summary, changes, planGateTransport, eff, ctx.sapAlias);
@@ -549,6 +574,11 @@ registerTool({
                 outcome = { approved: false, reason: 'sibling_write_skipped' };
             }
             else {
+                // LT-15 D6 (review M3) — stopped during the mint after the card before:
+                // the next card does not open; ids minted so far are dropped unused.
+                const stopD = stoppedBeforeCard(ctx);
+                if (stopD)
+                    return stopD;
                 outcome = await renderPerChangeApprovalV3(c, eff, displayTransport(c.op, args.transport, sessionTransport, c.owningTransport, project));
             }
             if (outcome.approved) {

package/dist/tools/dispatch-skill.js

@@ -44,7 +44,7 @@ registerTool({
         properties: {
             command: {
                 type: 'string',
-                description: 'Full slash command including arguments. Must start with `/`. Example: `/abap-rap --from @order-approval-system-design-2924-v1.cspeach.json`.',
+                description: 'Full slash command including arguments. Must start with `/`. Example: `/abap-rap --from @order-approval-system-design-2924-v1.cspeach.json`. Never put a transport description in it unless the person typed it.',
             },
         },
         required: ['command'],