@cspeach/cli 1.1.44 → 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';
@@ -152,10 +160,12 @@ import { applyLocalBuildConfig, applyStandaloneFileTools } from './tools/local-b
 import './tools/sap-read.js';
 import './tools/sap-write.js';
 import './tools/transport.js';
+import './tools/sap-run.js';
 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';
@@ -210,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.
@@ -537,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
@@ -819,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
@@ -930,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;
@@ -978,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`));
@@ -1165,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.
@@ -1189,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({
@@ -1317,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;
@@ -1384,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)
@@ -1519,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
@@ -1540,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
@@ -1968,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
@@ -2080,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();
@@ -3133,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.
@@ -3155,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({
@@ -3290,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;
@@ -3338,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)
@@ -3582,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
@@ -3597,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
@@ -4092,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/sap/profile-features.js

@@ -35,6 +35,11 @@ export const FEATURES = Object.freeze({
     'fugr.modules': { label: 'Function modules and function-group includes', collection: `${A}/functions/groups`, provenOnOurBox: true },
     'prog.includes': { label: 'Program includes', collection: `${A}/programs/includes`, provenOnOurBox: true },
     'ddic.tabletypes': { label: 'Table types', collection: `${A}/ddic/tabletypes`, provenOnOurBox: true },
+    // Part 3 (D15): no `since` (no cited release). The collections and the reads are
+    // proven on our box; the release is not, and these rows are about the collection.
+    'run.classrun': { label: 'Run a class (console)', collection: `${A}/oo/classrun`, provenOnOurBox: true },
+    'run.programrun': { label: 'Run a program', collection: `${A}/programs/programrun`, provenOnOurBox: true },
+    'cts.requests': { label: 'Transport requests (read, release)', collection: `${A}/cts/transportrequests`, provenOnOurBox: true },
 });
 export const FEATURE_IDS = Object.freeze(Object.keys(FEATURES));
 export function isFeatureId(s) {

package/dist/session/audit-export.js

@@ -62,6 +62,8 @@ const WRITE_TOOLS = new Set([
     // Final review I2 — SAP's RAP generator (tools/rap/generate-objects.ts) creates
     // the skeleton objects in one call; its row names them.
     'sap_generate_objects',
+    // Part 3 — a run executes code on the SAP system under an approval: it is audited.
+    'sap_run',
 ]);
 /**
  * Non-mutating tools that are interaction/plumbing, not object reads — excluded
@@ -156,6 +158,29 @@ function approvalCell(rec) {
     return `declined ✗${risk}`;
 }
 // ── Object / snapshot extraction ──────────────────────────────────────────
+/**
+ * The result as JSON, or its first line as JSON (a run's facts line), or the
+ * top-level fields a spilled preview still shows ("status": "stopped" comes
+ * before steps[] in the release envelope). {} when none of these read.
+ */
+function parseResultHead(result) {
+    const text = result ?? '';
+    try {
+        return asRecord(JSON.parse(text));
+    }
+    catch { /* next */ }
+    try {
+        return asRecord(JSON.parse(text.split('\n', 1)[0] ?? ''));
+    }
+    catch { /* next */ }
+    const top = (k) => new RegExp(`^ {2}"${k}": "([^"]+)"`, 'm').exec(text)?.[1];
+    const status = top('status');
+    if (!status)
+        return {};
+    const at = top('stopped_at');
+    const verdict = top('stop_verdict');
+    return { status, ...(at ? { stopped_at: at } : {}), ...(verdict ? { stop_verdict: verdict } : {}) };
+}
 function writeObject(tool, args, result) {
     switch (tool) {
         case 'sap_transport_create': {
@@ -180,8 +205,31 @@ function writeObject(tool, args, result) {
             // Last resort: name the operation, not the raw description.
             return 'transport';
         }
-        case 'sap_transport_release':
-            return str(args.transport) ?? '—';
+        case 'sap_transport_release': {
+            // Part 3 (D17): the row carries SAP's verdict; a stop names its step.
+            const tr = str(args.transport) ?? '—';
+            const r = parseResultHead(result);
+            const status = str(r.status);
+            if (!status)
+                return tr;
+            if (status === 'stopped') {
+                const last = Array.isArray(r.steps) && r.steps.length > 0 ? asRecord(r.steps[r.steps.length - 1]) : {};
+                const at = str(r.stopped_at) ?? str(last.number);
+                const verdict = str(r.stop_verdict) ?? str(last.verdict);
+                if (at && verdict)
+                    return `${tr} · stopped at ${at}: ${verdict}`;
+            }
+            return `${tr} · ${status}`;
+        }
+        case 'sap_run': {
+            // Part 3: `CLAS ZCL_X · ran` or the error code (the facts line is line 1 of a ran result).
+            const r = parseResultHead(result);
+            const what = [str(args.type), str(args.name)].filter(Boolean).join(' ') || '—';
+            if (r.ran === true)
+                return `${what} · ran`;
+            const err = str(r.error);
+            return err ? `${what} · ${err}` : what;
+        }
         case 'sap_update_method': {
             const cls = str(args.class_name) ?? '—';
             const m = str(args.method_name);

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;