@cspeach/cli 1.1.45 → 1.1.46

package/dist/repl.js

@@ -16,6 +16,10 @@ import { formatPanel } from './renderer/panel-rows.js';
 import { sanitizeControlChars } from './renderer/sanitize.js';
 import { formatRoutingLine } from './renderer/routing-line.js';
 import { handleUiLook, handleUiRendering } from './repl/ui-look-command.js';
+import { handleStyleCommand, pickStyleClassic, pickStyleInk } from './repl/style-command.js';
+import { handleLevelCommand, pickLevelClassic, pickLevelInk } from './repl/level-command.js';
+import { handleChatCommand } from './repl/chat-command.js';
+import { ChatUnavailableError } from './agent/chat-unavailable.js';
 import { CLI_VERSION } from './lib/version.js';
 import { createOfflineAdtClient } from './sap/offline-adt-client.js';
 import { STANDALONE_ALIAS } from './tools/index.js';
@@ -23,7 +27,11 @@ import { resumeStandaloneDecision, applySystemSwitch } from './repl/resume-stand
 import { clearAppFlow } from './lane/app-flow.js';
 import { clearJourneyFlow } from './journey/flow.js';
 import { createDispatchSlot, queuedStepView } from './session/queued-step.js';
-import { applyResumedSkill, isShortFollowUp } from './router/resume-routing.js';
+import { applyResumedSkill } from './router/resume-routing.js';
+import { ACK_PHRASES, wantsContinuation, isConversationalAck, decideLane, turnStatusLabel, applyLaneTools, chatFallbackOrigin } from './repl/chat-lane.js';
+import { CHAT_SKILL } from './agent/chat-prompt.js';
+import { setAssistantStyle } from './agent/style-state.js';
+import { setAssistantLevel } from './agent/level-state.js';
 import { readableInterruptReason, isUserStopReason } from './session/interrupt-reason.js';
 import { getStore } from './auth/api-key.js';
 import { readAuthFile } from './auth/auth-file.js';
@@ -157,6 +165,7 @@ import './tools/approval.js';
 import './tools/snapshot.js';
 import './tools/ask-question.js';
 import './tools/dispatch-skill.js';
+import './tools/hand-off.js';
 import './tools/todo.js';
 import './tools/filesystem/file-read.js';
 import './tools/tool-output-read.js';
@@ -211,68 +220,8 @@ function loadHistory() {
         // and were unreachable.
         .reverse());
 }
-/** Short user inputs that almost always mean "continue what we were doing"
- *  rather than "start a new task." When the previous turn left a skill
- *  in session.skill, an ack-only follow-up should route there instead of
- *  re-classifying as a fresh prompt (which produces nonsense like "yes"
- *  → /abap-explain at 35% confidence). */
-const ACK_PHRASES = new Set([
-    'yes', 'y', 'yeah', 'yep', 'yup', 'sure',
-    'ok', 'okay', 'k', 'kk',
-    'proceed', 'continue', 'go', 'go ahead', 'do it', 'do that', 'go on',
-    'no', 'n', 'nope', 'nah',
-    'stop', 'cancel', 'abort', 'never mind', 'nm',
-    'approve', 'approved', 'accept', 'accepted',
-    'decline', 'denied', 'reject', 'rejected',
-    'skip', 'next',
-]);
-/** Conversational acknowledgements that mean "I'm done with the previous
- *  turn, no further work needed." Distinct from ACK_PHRASES (which
- *  largely mean "yes/no to a question"). For these we don't classify,
- *  don't call any model — just print a friendly ack and return. The user
- *  isn't asking us to do more work; they're closing the prior thread.
- *
- *  2026-05-17 — Laeeq hit "thank you" being classified and run through
- *  /abap-explain, producing another huge code explanation. THIS is the
- *  fix for that. */
-const CONVERSATIONAL_ACKS = new Set([
-    'thanks', 'thank you', 'thank u', 'thx', 'tx', 'ty', 'ta',
-    'cool', 'nice', 'great', 'awesome', 'perfect',
-    'got it', 'gotit', 'understood',
-    'cheers',
-    // Common ackowledgements that follow a long answer.
-    'makes sense',
-]);
-/**
- * True when `trimmed` is one of CONVERSATIONAL_ACKS. We treat these as
- * "user closes the previous thread, no further work" — print a friendly
- * acknowledgement and return without classifying or calling any model.
- */
-function isConversationalAck(trimmed) {
-    const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
-    return CONVERSATIONAL_ACKS.has(normalized);
-}
-/**
- * Returns true when `trimmed` is a short acknowledgement-style follow-up
- * AND there is a previous skill to continue. Treats both bare acks and
- * short ack-prefixed phrases ("yes please", "no thanks") the same way.
- * Strips trailing punctuation so "yes." and "yes!" still register.
- */
-function isAckContinuation(trimmed, sessionSkill) {
-    if (!sessionSkill)
-        return false;
-    const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
-    if (ACK_PHRASES.has(normalized))
-        return true;
-    // "yes please", "go ahead and do it", "no thanks" — first word is an ack
-    // and the whole phrase is short enough to be a follow-up not a new task.
-    if (normalized.length <= 30) {
-        const firstWord = normalized.split(/\s+/)[0] ?? '';
-        if (ACK_PHRASES.has(firstWord))
-            return true;
-    }
-    return false;
-}
+// CONVERSATIONAL_ACKS / isConversationalAck live in repl/chat-lane.ts (moved
+// unchanged — the chat-lane decision reads the same set).
 /**
  * Returns true when `trimmed` is a bare ack ("y", "n", "ok", "cancel", ...)
  * with no surrounding context — regardless of whether a session.skill exists.
@@ -538,6 +487,15 @@ export async function runRepl(opts) {
     }
     let cfg = await loadConfig();
     setLook(cfg.ui.look);
+    // Chat lane (spec 2026-10-17 D1/D2/D5/D9) — the process lane and talking
+    // style. `laneSetting` is a `let`: Task 14's `/chat on|off` and the D11
+    // fallback (Task 15) reassign it, and decideLane reads it on every message.
+    // applyLaneTools is the one place the hand_off flag is enabled (interactive
+    // chat lane only — piped stdin keeps today's tools array and router).
+    let laneSetting = cfg.assistant.lane;
+    applyLaneTools(laneSetting, !!process.stdin.isTTY);
+    setAssistantStyle(cfg.assistant.style);
+    setAssistantLevel(cfg.assistant.level);
     // Apply the rendering mode BEFORE any shouldUseInk() call. This is the
     // interactive entry point, so it is never one-shot whatever argv holds. A
     // stored `classic` is retiring: read as auto, rewritten once, one dim notice
@@ -820,6 +778,8 @@ export async function runRepl(opts) {
         user: standalone ? '' : cfg.sap[selectedAlias].username,
         writeMode: startupWriteMode,
         standalone,
+        // Chat lane is interactive-only (applyLaneTools); piped stdin never chats.
+        chatLane: laneSetting === 'chat' && !!process.stdin.isTTY,
     });
     // v0.6 — when resuming, adopt the on-disk SessionState verbatim. This
     // preserves messages[], usage, last_skill, awaitingSkillAnswer, and the
@@ -931,6 +891,7 @@ export async function runRepl(opts) {
         tools: localTools,
         writeMode: startupWriteMode,
         cwd: process.cwd(),
+        chat: laneSetting === 'chat' && !!process.stdin.isTTY,
     };
     if (opts?.resumedSession) {
         const turnCount = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
@@ -979,7 +940,7 @@ export async function runRepl(opts) {
         }
     }
     else if (getLook() === 'panels') {
-        process.stdout.write(panelsStartTail({ status: panelsStatus, third: panelsHintLine(localTools), notices: startupNotices }));
+        process.stdout.write(panelsStartTail({ status: panelsStatus, third: panelsHintLine(localTools, laneSetting), notices: startupNotices }));
     }
     else {
         console.log(chalk.gray(`\nSession ${session.id} on ${selectedAlias}. Type /exit to quit.\n`));
@@ -1166,7 +1127,7 @@ export async function runRepl(opts) {
             if (trimmed === '/help' || trimmed === '/skills') {
                 // Phase D5 — route through chunkEmitter so help lands in Body,
                 // not above the Ink frame (which would scroll off + corrupt).
-                printHelp((line) => chunkEmitter.emit('chunk', line + '\n'));
+                printHelp((line) => chunkEmitter.emit('chunk', line + '\n'), { lane: laneSetting });
                 return;
             }
             // /usage (2026-10-09) — this month in credits, from the proxy's ledger.
@@ -1190,8 +1151,14 @@ export async function runRepl(opts) {
             if (trimmed === '/export' || trimmed.startsWith('/export ')) {
                 const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
                 const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+                // Word export (2026-10-19): /export docx <file>.md, same body as `cspeach export`.
+                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') });
+                    return;
+                }
                 if (sub !== 'audit') {
-                    chunkEmitter.emit('chunk', chalk.dim('\nUsage: /export audit [filename]\n'));
+                    chunkEmitter.emit('chunk', chalk.dim('\nUsage: /export audit [filename] · /export docx <file>.md\n'));
                     return;
                 }
                 await runExportAuditCommand({
@@ -1318,6 +1285,24 @@ export async function runRepl(opts) {
                 await handleUiRendering(arg, cfg, saveConfig, emit, shouldUseInk() ? 'ink' : 'classic');
                 return;
             }
+            // /style [value] — talking style (spec 2026-10-17 D9); saved like /ui look.
+            if (trimmed === '/style' || trimmed.startsWith('/style ')) {
+                if (!cfg.assistant)
+                    cfg.assistant = { ...DEFAULT_CONFIG.assistant };
+                const emit = (s) => chunkEmitter.emit('chunk', s + '\n');
+                await handleStyleCommand(trimmed.slice('/style'.length), cfg, saveConfig, emit, pickStyleInk);
+                return;
+            }
+            // /level [value] — who CSPeach is talking to (spec 2026-10-17 §10 D13); saved like /style.
+            // The D15 tip reads the write mode in force now (a /mode change this session counts).
+            if (trimmed === '/level' || trimmed.startsWith('/level ')) {
+                if (!cfg.assistant)
+                    cfg.assistant = { ...DEFAULT_CONFIG.assistant };
+                const emit = (s) => chunkEmitter.emit('chunk', s + '\n');
+                const writeModeNow = getEffectiveWriteMode(cfg.write_mode, cfg.sap[selectedAlias]?.role);
+                await handleLevelCommand(trimmed.slice('/level'.length), cfg, saveConfig, emit, pickLevelInk, writeModeNow);
+                return;
+            }
             // /reroute — re-dispatch session.lastUserPrompt to a different skill
             if (trimmed === '/reroute' || trimmed.startsWith('/reroute ')) {
                 session.awaitingSkillAnswer = false;
@@ -1385,7 +1370,19 @@ 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
-                chunkEmitter.emit('chunk', '\n' + formatInfo('Fresh start · the next prompt picks a skill again'));
+                chunkEmitter.emit('chunk', '\n' + (laneSetting === 'chat' ? formatInfo('Fresh start.') : formatInfo('Fresh start · the next prompt picks a skill again')));
+                return;
+            }
+            // /chat [on|off] (spec 2026-10-17 D6, owner amendment) — leave a workflow,
+            // or switch the lane now and save it; the next message reads the new lane.
+            if (trimmed === '/chat' || trimmed.startsWith('/chat ')) {
+                if (!cfg.assistant)
+                    cfg.assistant = { ...DEFAULT_CONFIG.assistant };
+                laneSetting = await handleChatCommand(trimmed.slice('/chat'.length), {
+                    lane: laneSetting, cfg, save: saveConfig, session, interactive: !!process.stdin.isTTY,
+                    emit: (s) => chunkEmitter.emit('chunk', '\n' + s + '\n'),
+                });
+                sapStateStore.update({ chatLane: laneSetting === 'chat' });
                 return;
             }
             // /transport — session current-transport state for Rule 9 (transport isolation)
@@ -1520,7 +1517,22 @@ export async function runRepl(opts) {
             const previousObject = session.last_object ?? null;
             const shortcutSkill = parsed.skill;
             let skill = shortcutSkill;
-            if (!skill) {
+            // Chat lane (D1/D6/D-G) — decided here, once, before today's routing
+            // block. Skills lane ⇒ always `explicit` or `route` (block unchanged).
+            const laneDecision = decideLane({
+                laneSetting, interactive: !!process.stdin.isTTY, explicitSkill: shortcutSkill, trimmed,
+                sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill,
+            });
+            if (laneDecision.kind === 'chat') {
+                // M1 — just talk: no router, no routing line, no picker.
+                skill = CHAT_SKILL;
+            }
+            else if (laneDecision.kind === 'continue') {
+                // D6 — the workflow keeps the turn; the one existing line says so.
+                chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'continuing', skill: laneDecision.skill }));
+                skill = laneDecision.skill;
+            }
+            else if (!skill) {
                 // v0.3.1 — if the last skill turn ended with a question, route the
                 // user's reply back to the same skill instead of reclassifying. This
                 // stops short answers like "1" or "S/4 on-prem" from being treated
@@ -1541,9 +1553,10 @@ 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).
-                if ((session.awaitingSkillAnswer || (resumedSkill !== null && isShortFollowUp(trimmed)) || isAckContinuation(trimmed, session.skill)) && session.skill) {
-                    chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'continuing', skill: session.skill }));
-                    skill = session.skill;
+                const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill });
+                if (continuedSkill) {
+                    chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'continuing', skill: continuedSkill }));
+                    skill = continuedSkill;
                 }
                 else if (isBareAck(trimmed)) {
                     // Bare "y" / "n" / "cancel" with no skill to continue — typing this
@@ -1969,7 +1982,7 @@ export async function runRepl(opts) {
             // loop.ts) so the try/finally GUARANTEES the row clears even when the
             // turn throws; loop.ts only narrates activity changes in between.
             // (turnStatusEmitter is the module-level singleton import — BUG-2b.)
-            turnStatusEmitter.start(`/${skill}`);
+            turnStatusEmitter.start(turnStatusLabel(skill));
             try {
                 // Task 6 (review M-2) — guarded chain start: announce and disable
                 // auto_approve for this phase's turn (request_approval consults the
@@ -2081,20 +2094,33 @@ export async function runRepl(opts) {
                 });
             }
             catch (err) {
-                // 2026-09-24 — print the turn-error block INTO the conversation (it
-                // stays on screen) instead of the overlay box that vanished after 5 s
-                // — a customer's dropped turn left no trace of what happened or what
-                // to do. Same block classic mode prints; in-session it leads with
-                // "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'),
-                });
+                if (err instanceof ChatUnavailableError) {
+                    // D11 — this server has no chat lane (404/403 for _chat; the loop
+                    // already withdrew the turn). Switch this PROCESS to skill routing
+                    // (config is not saved) and re-run the same message once through
+                    // today's router; the queued step shows the one notice line in
+                    // place of a second echo. The re-run decides `route`, so it can
+                    // never throw ChatUnavailableError again.
+                    laneSetting = 'skills';
+                    sapStateStore.update({ chatLane: false });
+                    pendingDispatchAccessor.set(trimmed, chatFallbackOrigin());
+                }
+                else {
+                    // 2026-09-24 — print the turn-error block INTO the conversation (it
+                    // stays on screen) instead of the overlay box that vanished after 5 s
+                    // — a customer's dropped turn left no trace of what happened or what
+                    // to do. Same block classic mode prints; in-session it leads with
+                    // "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'),
+                    });
+                }
             }
             finally {
                 turnStatusEmitter.stop();
@@ -3134,7 +3160,7 @@ export async function runRepl(opts) {
         }
         // /help and /skills show the skill catalog flat-list.
         if (trimmed === '/help' || trimmed === '/skills') {
-            printHelp();
+            printHelp(undefined, { lane: laneSetting });
             continue;
         }
         // /usage (2026-10-09) — classic mirror of the Ink handler above.
@@ -3156,8 +3182,14 @@ export async function runRepl(opts) {
         if (trimmed === '/export' || trimmed.startsWith('/export ')) {
             const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
             const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+            // Word export (2026-10-19): /export docx <file>.md, same body as `cspeach export`.
+            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) });
+                continue;
+            }
             if (sub !== 'audit') {
-                console.log(chalk.dim('Usage: /export audit [filename]'));
+                console.log(chalk.dim('Usage: /export audit [filename] · /export docx <file>.md'));
                 continue;
             }
             await runExportAuditCommand({
@@ -3291,6 +3323,21 @@ export async function runRepl(opts) {
             await handleUiRendering(arg, cfg, saveConfig, (s) => console.log(s), shouldUseInk() ? 'ink' : 'classic');
             continue;
         }
+        // /style [value] — talking style (spec 2026-10-17 D9); saved like /ui look.
+        if (trimmed === '/style' || trimmed.startsWith('/style ')) {
+            if (!cfg.assistant)
+                cfg.assistant = { ...DEFAULT_CONFIG.assistant };
+            await handleStyleCommand(trimmed.slice('/style'.length), cfg, saveConfig, (s) => console.log(s), pickStyleClassic);
+            continue;
+        }
+        // /level [value] — who CSPeach is talking to (spec 2026-10-17 §10 D13); saved like /style.
+        if (trimmed === '/level' || trimmed.startsWith('/level ')) {
+            if (!cfg.assistant)
+                cfg.assistant = { ...DEFAULT_CONFIG.assistant };
+            const writeModeNow = getEffectiveWriteMode(cfg.write_mode, cfg.sap[selectedAlias]?.role);
+            await handleLevelCommand(trimmed.slice('/level'.length), cfg, saveConfig, (s) => console.log(s), pickLevelClassic, writeModeNow);
+            continue;
+        }
         // /reroute — re-dispatch session.lastUserPrompt to a different skill
         if (trimmed === '/reroute' || trimmed.startsWith('/reroute ')) {
             session.awaitingSkillAnswer = false;
@@ -3339,7 +3386,18 @@ export async function runRepl(opts) {
             session.todos = []; // P2 — /new clears the plan (spec §4)
             clearAppFlow(session); // Task 7 — /new ends an /abap-app flow
             clearJourneyFlow(session); // Task 3 — and a clean-core journey
-            console.log(formatInfo('Fresh start · the next prompt picks a skill again').trimEnd());
+            console.log((laneSetting === 'chat' ? formatInfo('Fresh start.') : formatInfo('Fresh start · the next prompt picks a skill again')).trimEnd());
+            continue;
+        }
+        // /chat [on|off] — classic mirror of the Ink handler above.
+        if (trimmed === '/chat' || trimmed.startsWith('/chat ')) {
+            if (!cfg.assistant)
+                cfg.assistant = { ...DEFAULT_CONFIG.assistant };
+            laneSetting = await handleChatCommand(trimmed.slice('/chat'.length), {
+                lane: laneSetting, cfg, save: saveConfig, session, interactive: !!process.stdin.isTTY,
+                emit: (s) => console.log(s),
+            });
+            sapStateStore.update({ chatLane: laneSetting === 'chat' });
             continue;
         }
         // /transport — session current-transport state for Rule 9 (transport isolation)
@@ -3583,7 +3641,20 @@ export async function runRepl(opts) {
         const previousSkill = session.skill; // snapshot before this turn dispatches
         const previousObject = session.last_object ?? null; // carries from two turns ago
         let skill = parsed.skill;
-        if (!skill) {
+        // Chat lane (D1/D6/D-G) — classic mirror of the Ink decision. Piped stdin
+        // is a scripting surface and keeps today's router (interactive: false).
+        const laneDecision = decideLane({
+            laneSetting, interactive: !pipedStdin, explicitSkill: parsed.skill, trimmed,
+            sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill,
+        });
+        if (laneDecision.kind === 'chat') {
+            skill = CHAT_SKILL;
+        }
+        else if (laneDecision.kind === 'continue') {
+            console.log(formatRoutingLine({ kind: 'continuing', skill: laneDecision.skill }).trimEnd());
+            skill = laneDecision.skill;
+        }
+        else if (!skill) {
             // v0.3.1 — if the last skill turn ended with a question, route the
             // user's reply back to the same skill instead of reclassifying. This
             // stops short answers like "1" or "S/4 on-prem" from being treated
@@ -3598,9 +3669,10 @@ export async function runRepl(opts) {
                 continue;
             }
             // Round 6 item 4c / review I2 — see the Ink path.
-            if ((session.awaitingSkillAnswer || (resumedSkill !== null && isShortFollowUp(trimmed)) || isAckContinuation(trimmed, session.skill)) && session.skill) {
-                console.log(formatRoutingLine({ kind: 'continuing', skill: session.skill }).trimEnd());
-                skill = session.skill;
+            const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill });
+            if (continuedSkill) {
+                console.log(formatRoutingLine({ kind: 'continuing', skill: continuedSkill }).trimEnd());
+                skill = continuedSkill;
             }
             else if (isBareAck(trimmed)) {
                 // Bare "y" / "n" / "cancel" with no skill to continue — almost always
@@ -4093,18 +4165,27 @@ export async function runRepl(opts) {
             });
         }
         catch (err) {
-            // v0.6 — graceful turn-error UX. The loop's try/catch already
-            // persisted any partial assistant content to session.messages and
-            // wrote the streamed prose to ~/.cspeach/streams/. Here we only
-            // surface a clean 4–6 line diagnostic + write a full log so the
-            // user can resume cleanly. See agent/turn-error-ux.ts for details.
-            await renderTurnError({
-                err,
-                session,
-                userInterrupted: interruptedByUser,
-                inSession: true,
-                print: (line) => console.error(line),
-            });
+            if (err instanceof ChatUnavailableError) {
+                // D11 — classic mirror of the Ink catch: process lane only, no save;
+                // the loop-top slot consumer re-runs the message once.
+                laneSetting = 'skills';
+                sapStateStore.update({ chatLane: false });
+                pendingDispatchAccessor.set(trimmed, chatFallbackOrigin());
+            }
+            else {
+                // v0.6 — graceful turn-error UX. The loop's try/catch already
+                // persisted any partial assistant content to session.messages and
+                // wrote the streamed prose to ~/.cspeach/streams/. Here we only
+                // surface a clean 4–6 line diagnostic + write a full log so the
+                // user can resume cleanly. See agent/turn-error-ux.ts for details.
+                await renderTurnError({
+                    err,
+                    session,
+                    userInterrupted: interruptedByUser,
+                    inSession: true,
+                    print: (line) => console.error(line),
+                });
+            }
         }
         finally {
             rl.removeListener('SIGINT', onSigint);

package/dist/session/queued-step.js

@@ -13,6 +13,7 @@
 // the exact command was written by the model, so it shows as "Auto-routed: …",
 // never as typed. An untagged command keeps the old echo.
 import { shownUpTo } from '../register/atc-file.js';
+import { paint } from '../renderer/theme.js';
 export function createDispatchSlot() {
     let cmd = null;
     let origin = null;
@@ -41,5 +42,8 @@ export function queuedStepView(origin) {
     if (!origin)
         return { echo: true };
     const line = origin.line ? shownUpTo(origin.line, 160).trim() : '';
-    return { echo: false, line: line || null };
+    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 };
 }

package/dist/session/schema.js

@@ -19,5 +19,6 @@ export function newSession(id, sapSystem, skill, model, project) {
         lastUserPrompt: null,
         awaitingSkillAnswer: false,
         agentMode: 'skill',
+        lane: 'skill',
     };
 }

package/dist/session/store.js

@@ -72,6 +72,10 @@ function validateSchema(parsed) {
     // Phase 4 chunk 4A: agentMode defaults to 'skill' for sessions written
     // before this chunk landed. Mirrors the lastUserPrompt back-compat above.
     parsed.agentMode ??= 'skill';
+    // Chat lane (2026-10-17 D7): older files have no lane — they ran skill turns.
+    // Anything but 'chat' (missing or hand-edited) loads as 'skill', the safe default.
+    if (parsed.lane !== 'chat')
+        parsed.lane = 'skill';
     // 2026-10-08: sessions are listed per folder. Older files have no folder.
     parsed.project_dir ??= null;
     parsed.project_id ??= null;

package/dist/tools/hand-off.js

@@ -0,0 +1,86 @@
+/**
+ * hand_off (chat lane, spec 2026-10-17 D5) — the chat's one way into a guided
+ * workflow. Queues `/<skill> <request>` through the existing pendingDispatch
+ * slot (shown as one line "→ /abap-x", never as the person's own line); the
+ * chat turn then ends and the workflow runs with its own plan + approvals.
+ * No extra consent card (D5): the workflow asks before any write.
+ * Refused outside the chat lane; dispatch_skill stays the skills' own switch.
+ *
+ * Flag-gated: only a chat-lane process enables it (Task 11), so a skills-lane
+ * session never lists it and its tools array stays byte-identical to today.
+ */
+import { registerTool } from './index.js';
+import { isPlanResumeCommand } from '../commands/plan-resume.js';
+import { SKILL_CATALOG, resolveSkillAlias } from '../skill-catalog.js';
+/** Longest request hand_off queues (after whitespace is collapsed). */
+export const HAND_OFF_REQUEST_MAX = 500;
+export const HAND_OFF_LINE = (skill) => `→ /${skill}`;
+export const buildHandOffCommand = (skill, request) => `/${skill} ${request}`;
+const CATALOG_NAMES = new Set(SKILL_CATALOG.map((s) => s.name));
+/**
+ * A workflow name as the model wrote it → its catalog name, or null.
+ * Strips one leading `/`, lowercases, resolves a retired alias, and accepts a
+ * bare name ("refactor" → "abap-refactor"). Never `_chat` (not in the catalog).
+ */
+export function normaliseSkill(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const bare = raw.trim().replace(/^\//, '').toLowerCase();
+    if (!bare)
+        return null;
+    for (const candidate of [bare, `abap-${bare}`]) {
+        const resolved = resolveSkillAlias(candidate);
+        if (CATALOG_NAMES.has(resolved))
+            return resolved;
+    }
+    return null;
+}
+registerTool({
+    name: 'hand_off',
+    description: 'Hand this conversation to a CSPeach guided workflow when the developer wants a change made in SAP or a complete deliverable (a full review, a handover document, an upgrade scan). The workflow shows its plan and asks before it writes, so do not ask "shall I hand off?" first — say in one line what you would change, then call this. skill: the workflow name (e.g. "abap-refactor", "abap-generate", "abap-transport", "abap-review"). request: what to do, one clear sentence with object names. After this returns, end the turn.',
+    isMutating: false,
+    flagGated: true,
+    category: 'session',
+    input_schema: {
+        type: 'object',
+        properties: {
+            skill: { type: 'string', description: 'Workflow name without the slash, e.g. "abap-refactor".' },
+            request: { type: 'string', description: 'What the workflow should do, with object names. One sentence, at most 500 characters, no flags.' },
+        },
+        required: ['skill', 'request'],
+    },
+    handler: async (args, ctx) => {
+        const bad = (error, reason) => ({ is_error: true, content: JSON.stringify({ error, reason }) });
+        if (ctx.session?.lane !== 'chat') {
+            return bad('HAND_OFF_OUTSIDE_CHAT', 'hand_off is only for the chat; in a workflow, continue with the workflow (dispatch_skill switches workflows after the person agreed).');
+        }
+        const skill = normaliseSkill(args.skill);
+        if (!skill) {
+            return bad('HAND_OFF_UNKNOWN_SKILL', `unknown workflow "${String(args.skill ?? '')}". Use one of: ${SKILL_CATALOG.map((s) => s.name).join(', ')}`);
+        }
+        const request = typeof args.request === 'string' ? args.request.trim().replace(/\s+/g, ' ') : '';
+        if (!request)
+            return bad('HAND_OFF_INVALID', 'request must say what the workflow should do');
+        if (request.length > HAND_OFF_REQUEST_MAX) {
+            return bad('HAND_OFF_INVALID', `request is too long (${request.length} chars; at most ${HAND_OFF_REQUEST_MAX}). Say it in one short sentence with the object names.`);
+        }
+        const command = buildHandOffCommand(skill, request);
+        if (isPlanResumeCommand(command)) {
+            return bad('PLAN_RESUME_HARNESS_OWNED', 'Plan continuation is owned by CSPeach; never hand off "/abap-plan --resume".');
+        }
+        if (request.startsWith('--')) {
+            return bad('HAND_OFF_INVALID', 'request must start with what to do, not with flags (--…). Say it in one plain sentence with the object names.');
+        }
+        if (!ctx.pendingDispatch) {
+            return bad('DISPATCH_UNSUPPORTED', 'no dispatch slot in this context (one-shot or test); tell the developer which /abap-… command to run instead');
+        }
+        ctx.pendingDispatch.set(command, { by: 'hand_off', line: HAND_OFF_LINE(skill) });
+        return {
+            content: JSON.stringify({
+                ok: true,
+                queued: command,
+                note: 'The workflow runs next and asks before it writes. End the turn now with at most one short line; do not print the command.',
+            }),
+        };
+    },
+});

package/dist/tools/tool-loading.js

@@ -86,6 +86,9 @@ export const SKILL_STARTERS = Object.freeze({
     // Selection texts (2026-10-04): a new PARAMETERS / SELECT-OPTIONS gets its text in the same change.
     'abap-refactor': ['sap_get_text_elements', 'sap_set_text_elements'],
     'abap-generate': ['sap_get_text_elements', 'sap_set_text_elements', 'sap_run'],
+    // Chat lane (D5): the hand-off tool is loaded on chat turns; flag-gated, so a skills-lane session never lists it.
+    // `_chat` is the one SKILL_STARTERS key that is not a catalog skill (pinned in tool-loading.test.ts).
+    '_chat': ['hand_off'],
 });
 /** The starter tools for a skill; unknown skill (or none) ⇒ []. */
 export function startersForSkill(skill) {

package/dist/ui/sap-state-store.js

@@ -20,6 +20,7 @@ const DEFAULT_STATE = {
     creditsMode: false, creditsSessionTotal: 0, creditsBalance: null,
     creditsUnitLabel: 'credits', creditsPending: false,
     standalone: false,
+    chatLane: false,
 };
 /**
  * Rate limiter: calls `fn` at most once every `minIntervalMs`. Trailing-only:

package/dist/ui/widgets/ask-card.js

@@ -178,6 +178,7 @@ export function toCardQuestions(request) {
             options: freeText ? [] : request.choices,
             otherRow: false,
             defaultValue: request.defaultValue,
+            cursorValue: request.cursorValue,
             keys: request.keys,
         }];
 }
@@ -323,7 +324,7 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
     // Focus slots: 0..n-1 = questions; n = the Review step (2+ questions,
     // reachable only once every question has an answer).
     const [focus, setFocus] = useState(0);
-    const [cursors, setCursors] = useState(() => questions.map((qq) => Math.max(0, qq.options.findIndex((o) => o.value === qq.defaultValue))));
+    const [cursors, setCursors] = useState(() => questions.map((qq) => Math.max(0, qq.options.findIndex((o) => o.value === (qq.defaultValue ?? qq.cursorValue)))));
     const [ticks, setTicks] = useState(() => questions.map(() => new Set()));
     const [drafts, setDrafts] = useState(() => questions.map(() => ''));
     const [answers, setAnswers] = useState(() => questions.map(() => null));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.45",
+  "version": "1.1.46",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, signed skills, safety gates.",
   "keywords": [
     "abap",
@@ -74,6 +74,7 @@
     "clipboardy": "^5.3.1",
     "cross-spawn": "^7.0.6",
     "diff": "^9.0.0",
+    "docx": "^9.0.2",
     "ejs": "3.1.10",
     "fuse.js": "^7.0.0",
     "ink": "^5.0.0",
@@ -104,7 +105,6 @@
     "@types/turndown": "^5.0.5",
     "@ui5/builder": "4.3.2",
     "@ui5/fs": "4.0.6",
-    "docx": "^9.0.2",
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
     "pdf-lib": "^1.17.1",