@cspeach/cli 0.6.0

package/dist/repl.js

@@ -0,0 +1,1383 @@
+import chalk from 'chalk';
+// The promises-based `readline.createInterface` accepts the same options
+// as the callback version but its TypeScript typings do not expose
+// `rl.history` (only the callback module's interface does). If a future
+// version needs runtime history manipulation (trim, search), cast to the
+// callback-module's InterfaceConstructor signature or import from
+// 'node:readline' directly for that specific operation.
+import * as readline from 'node:readline/promises';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { select, password as promptPassword } from '@inquirer/prompts';
+import { loadConfig } from './config/loader.js';
+import { getStore } from './auth/api-key.js';
+import { readAuthFile } from './auth/auth-file.js';
+import { fetchMe } from './auth/me.js';
+import { formatLoginBanner } from './ui/login-banner.js';
+import { printStartupBanner, printKeytarFallbackBanner } from './renderer/banners.js';
+import { runAddSapWizard } from './sap/onboarding.js';
+import { getConnection } from './sap/connection-manager.js';
+import { AdtClient } from '@cspeach/sap-client';
+import { makeSessionId, saveSession } from './session/store.js';
+import { newSession } from './session/schema.js';
+import { createProviderForMode } from './agent/providers/factory.js';
+import { runTurn } from './agent/loop.js';
+import { renderTurnError } from './agent/turn-error-ux.js';
+import { classifyPrompt, parseShortcut } from './router/classifier.js';
+import { decideRouting } from './router/routing-decision.js';
+import { coachingPickerClassic } from './ui/coaching-picker-classic.js';
+import { coachingPickerEmitter } from './ui/coaching-picker-emitter.js';
+import { PICK_CANCELLED } from './ui/skill-picker.js';
+import { registerReadline, withInquirer } from './repl/inquirer-guard.js';
+import { maybePromptWorkspaceMigration } from './projects/migration.js';
+import { slashCompleter } from './repl/slash-completer.js';
+import { openSlashPicker, isExactSlashMatch } from './repl/slash-picker.js';
+import { openAtPicker, pendingAtTokenPrefix } from './repl/at-picker.js';
+import { atCompleter } from './repl/at-completer.js';
+/**
+ * Pre-fill the readline buffer with `text`, cursor at end, and trigger
+ * a redraw. Bypasses rl.write() — which simulates per-character
+ * keystrokes and races with rl.question's prompt-reset, leaving the
+ * visible characters painted while the internal buffer stays empty
+ * (so the first user keystroke wipes the pre-fill on redraw).
+ *
+ * Direct buffer manipulation via `line`/`cursor` + `_refreshLine` is
+ * not part of the public readline API, but the fields have been
+ * stable across Node 16/18/20/22 and are what every interactive-prompt
+ * library (inquirer, prompts, ink-text-input) ends up calling. The
+ * `_refreshLine?.()` optional-chain is the safety net for any future
+ * Node where the method goes away.
+ */
+function prefillReadline(rl, text) {
+    const internal = rl;
+    internal.line = text;
+    internal.cursor = text.length;
+    internal._refreshLine?.();
+}
+import { BracketedPasteDecoder, enableBracketedPaste, disableBracketedPaste, } from './repl/bracketed-paste.js';
+import { printHelp } from './commands/help.js';
+import { printStatusFooter } from './renderer/status-footer.js';
+import { shouldUseInk, setRenderingOverride } from './renderer/tty.js';
+import { saveConfig } from './config/loader.js';
+import { EventEmitter } from 'node:events';
+import { parseAndValidateReroute } from './commands/reroute.js';
+import { SKILL_CATALOG } from './skill-catalog.js';
+import { replPreviewHook } from './repl/update-method-preview-hook.js';
+import { getCurrentTransport, handleTransportCommand } from './repl/current-transport.js';
+// Side-effect imports so tool registrations happen before listTools() is called.
+import './tools/sap-read.js';
+import './tools/sap-write.js';
+import './tools/transport.js';
+import './tools/approval.js';
+import './tools/snapshot.js';
+import './tools/ask-question.js';
+import './tools/dispatch-skill.js';
+import './tools/filesystem/file-read.js';
+import './tools/filesystem/file-edit.js';
+import './tools/filesystem/file-write.js';
+import './tools/filesystem/glob.js';
+import './tools/filesystem/grep.js';
+import './tools/shell/shell_exec.js';
+import './tools/web/web_fetch.js';
+import './tools/web/web_search.js';
+import './tools/project/project_context_get.js';
+import './tools/project/playbook_get.js';
+import './tools/project/convention_get.js';
+import './tools/subagent/_background-shared.js';
+import './tools/subagent/background_run.js';
+import './tools/subagent/monitor_emit.js';
+import './tools/subagent/schedule_create.js';
+import './tools/subagent/agent_run.js';
+const PEACH = '#FFCBA4';
+const HISTORY_FILE = path.join(os.homedir(), '.cspeach', 'history');
+const HISTORY_SIZE = 500;
+function loadHistory() {
+    try {
+        const raw = fs.readFileSync(HISTORY_FILE, 'utf-8');
+        return raw
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0)
+            .slice(-HISTORY_SIZE)
+            // readline expects history[0] to be the MOST RECENT entry (arrow-up
+            // walks from index 0 backwards in time). The on-disk file is
+            // chronologically appended — oldest at top, newest at bottom — so
+            // after slicing the last N lines we need to reverse them. Without
+            // this, arrow-up showed the user the oldest 500 entries first; new
+            // ones (correctly persisted to disk) sat at the far end of the buffer
+            // and were unreachable.
+            .reverse();
+    }
+    catch {
+        return [];
+    }
+}
+function appendHistory(line) {
+    try {
+        fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+        fs.appendFileSync(HISTORY_FILE, line + '\n', 'utf-8');
+    }
+    catch {
+        // Non-fatal — history persistence failure must never crash the REPL.
+    }
+}
+/** 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',
+]);
+/**
+ * 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;
+}
+/**
+ * Returns true when `trimmed` is a bare ack ("y", "n", "ok", "cancel", ...)
+ * with no surrounding context — regardless of whether a session.skill exists.
+ *
+ * Used to short-circuit the classifier when the user types a stray ack but
+ * there's no active skill to continue. Without this, after an aborted turn
+ * (--from declined, --status passthrough, etc.) the classifier scores the
+ * lonely "n" against every skill and shows the coaching picker — exactly
+ * the "nonsense like 'yes' → /abap-explain at 35%" failure that ACK_PHRASES
+ * was introduced to prevent.
+ */
+function isBareAck(trimmed) {
+    const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
+    return ACK_PHRASES.has(normalized);
+}
+/**
+ * Build CoachingPickerParams from a ClassifyResult + SKILL_CATALOG.
+ * Picks top-3 candidates (top-1 + top-2 alternates), looks up description
+ * and whenToUse from the catalog per entry. Falls back to entry.description
+ * if whenToUse is missing (defensive — drift-guard test should prevent this).
+ */
+function buildCoachingParams(result, prompt, preSelect) {
+    const candidates = [result.skill, ...result.alternates].slice(0, 3);
+    const options = candidates.map((skill) => {
+        const entry = SKILL_CATALOG.find((e) => e.name === skill);
+        return {
+            skill,
+            // Only the top-1 has a real confidence; alternates currently are skill-
+            // name only (Layer B gap). Show top-1's confidence for the first entry,
+            // 0 for alternates (rendered as "0%") — a visual cue that these are
+            // alternate suggestions, not separately scored.
+            confidence: skill === result.skill ? result.confidence : 0,
+            whatItDoes: entry?.description ?? 'no description',
+            whenToPick: entry?.whenToUse ?? entry?.description ?? 'no description',
+        };
+    });
+    return { prompt, options, preSelect };
+}
+export async function runRepl(opts) {
+    printStartupBanner();
+    // v0.6 — surface interrupted sessions at startup so the developer doesn't
+    // have to remember the session id from the crash UX. Like `git stash list`
+    // for resilience: if you have any unfinished work, you see it immediately.
+    // Skip when --resume is already in flight (the user is resuming right now).
+    if (!opts?.resumedSession) {
+        try {
+            const { countInterruptedSessions } = await import('./session/store.js');
+            const n = await countInterruptedSessions();
+            if (n > 0) {
+                console.log(chalk.yellow.bold(`⚠  You have ${n} interrupted session${n === 1 ? '' : 's'}.`));
+                console.log(chalk.yellow(`   Recover with: cspeach --resume    (picks the right one from a list)\n`));
+            }
+        }
+        catch { /* startup banner is best-effort */ }
+    }
+    // Phase 2.1 of Track B — when CSPEACH_PROJECT_CONTEXT=on the dogfooder
+    // is on the experimental enrichment path. Surface that visibly so they
+    // (a) know it's active and (b) can correlate session behavior with the
+    // flag state when running `cspeach analyze project-context` later. The
+    // flag is process-scoped, so this prints at most once per CLI launch.
+    try {
+        const { isFlagOn } = await import('./agent/maybe-build-project-context.js');
+        if (isFlagOn()) {
+            console.log(chalk.cyan(`[project-context] enabled (cwd=${process.cwd()})`));
+            console.log(chalk.dim('  unset CSPEACH_PROJECT_CONTEXT to disable; run `cspeach analyze project-context` later to compare.\n'));
+        }
+    }
+    catch { /* startup banner is best-effort */ }
+    // Customer-onboarding (Task 9): if the new auth-file is present, hit /v1/me
+    // and render the verbose login banner. Falls through to the legacy keytar
+    // flow below when the file is absent (back-compat for pre-`cspeach login`
+    // users).
+    try {
+        const authFile = await readAuthFile();
+        if (authFile) {
+            const cfgEarly = await loadConfig();
+            const meResult = await fetchMe({ proxyUrl: cfgEarly.proxy_url, apiKey: authFile.apiKey });
+            if (!meResult.ok) {
+                if (meResult.status === 401) {
+                    console.log(chalk.yellow('Your CSPeach session is invalid or expired. Run `cspeach login` to re-authenticate.'));
+                    return 1;
+                }
+                console.log(chalk.dim(`(could not refresh /v1/me — ${meResult.error})`));
+            }
+            else {
+                const banner = formatLoginBanner(meResult.profile);
+                console.log(banner.line);
+                if (banner.warningLine)
+                    console.log(chalk.yellow(banner.warningLine));
+            }
+        }
+    }
+    catch { /* banner is best-effort — never block REPL startup */ }
+    const store = await getStore();
+    if (!(await store.isKeychainAvailable())) {
+        printKeytarFallbackBanner();
+    }
+    let apiKey = await store.get();
+    if (!apiKey) {
+        const entered = await promptPassword({
+            message: 'Paste your CSPeach API key (from invite email):',
+            mask: '*',
+        });
+        await store.set(entered);
+        apiKey = entered;
+    }
+    let cfg = await loadConfig();
+    // Apply user-configured rendering override BEFORE any shouldUseInk() call.
+    setRenderingOverride(cfg.ui.rendering);
+    if (Object.keys(cfg.sap).length === 0) {
+        console.log(chalk.yellow('\nNo SAP systems configured. Starting onboarding wizard.'));
+        await runAddSapWizard();
+        cfg = await loadConfig();
+    }
+    // Task C.10 — surface the current write_mode prominently. advisory-only gets
+    // a bold yellow banner (no-writes is a surprising-enough state that the user
+    // should not miss it). Other modes get a quiet one-liner so the state is
+    // always visible without competing with the peach banner above.
+    if (cfg.write_mode === 'advisory-only') {
+        console.log(chalk.yellow.bold('⚠  Write mode: ADVISORY (writes proposed, never executed)'));
+        console.log(chalk.yellow('   Change via: cspeach config set write_mode approval-gated\n'));
+    }
+    else {
+        console.log(chalk.gray(`Write mode: ${cfg.write_mode}\n`));
+    }
+    const aliases = Object.keys(cfg.sap);
+    // C.1 — --sap-alias flag override skips the interactive picker
+    let selectedAlias;
+    if (opts?.sapAlias) {
+        console.log(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
+        selectedAlias = opts.sapAlias;
+    }
+    else if (opts?.resumedSession?.sap_system) {
+        // v0.6 — resumed session knows its SAP. Skip the picker.
+        selectedAlias = opts.resumedSession.sap_system;
+        console.log(chalk.dim(`Resumed on SAP ${selectedAlias}`));
+    }
+    else {
+        selectedAlias =
+            aliases.length === 1
+                ? aliases[0]
+                : await select({
+                    message: 'Pick a SAP system:',
+                    choices: aliases.map((a) => ({ value: a, name: a })),
+                });
+    }
+    const conn = await getConnection(selectedAlias, cfg.sap[selectedAlias]);
+    const adt = new AdtClient(conn);
+    // v0.6 — when resuming, adopt the on-disk SessionState verbatim. This
+    // preserves messages[], usage, last_skill, awaitingSkillAnswer, and the
+    // turnInterrupted flag from the prior run. Skipping newSession() avoids
+    // overwriting the saved file with an empty fresh one.
+    const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, cfg.default_model);
+    if (!opts?.resumedSession) {
+        await saveSession(session);
+    }
+    const provider = createProviderForMode(cfg, async () => {
+        const key = await store.get();
+        if (!key)
+            throw new Error('No API key configured');
+        return key;
+    });
+    if (opts?.resumedSession) {
+        const turnCount = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
+        console.log(chalk.cyan(`\nResumed session ${session.id} on ${selectedAlias} — ${turnCount} prior turn(s).`));
+        if (session.turnInterrupted) {
+            const reason = session.turnInterruptedReason ?? 'unknown';
+            console.log(chalk.yellow(`⚠  Last turn was interrupted (${reason}).`));
+            console.log(chalk.yellow(`   Type \"continue\" to ask the model to finish where it left off.`));
+        }
+        console.log(chalk.gray(`Type /exit to quit.\n`));
+    }
+    else {
+        console.log(chalk.gray(`\nSession ${session.id} on ${selectedAlias}. Type /exit to quit.\n`));
+    }
+    // B.3 — real session-scoped transport accessor. getCurrentTransport() reads the
+    // module-scope singleton in repl/current-transport.ts which is mutated by
+    // sap_transport_create (success path) and the /transport slash command.
+    // Defined at outer scope so both the Ink branch and the classic readline branch
+    // can inject it into ToolContext without duplication.
+    const currentTransportAccessor = { get: getCurrentTransport };
+    // 2026-05-08: pendingDispatch slot for the auto-route-after-picker UX.
+    // The dispatch_skill tool writes a slash command here when the user
+    // explicitly approved a "Switch to /abap-X" via ask_question. After
+    // each runTurn we check this slot and, if set, route that command as
+    // the next user submission — no Enter press required. Lives at outer
+    // scope so both the Ink and readline branches share the same instance.
+    // Cleared at the start of every consume cycle so a stale value never
+    // re-fires.
+    let pendingDispatchValue = null;
+    const pendingDispatchAccessor = {
+        get: () => pendingDispatchValue,
+        set: (cmd) => { pendingDispatchValue = cmd; },
+    };
+    // v0.3: Ink-mode REPL branch. When running under a real TTY in REPL mode
+    // (not one-shot, not CI), mount the <App /> frame instead of the readline
+    // loop. The non-Ink path below is preserved byte-for-byte for piped/CI
+    // invocations.
+    if (shouldUseInk()) {
+        const { render } = await import('ink');
+        const { App } = await import('./ui/app.js');
+        const React = (await import('react')).default;
+        const chunkEmitter = new EventEmitter();
+        let done = false;
+        let resolveDone = null;
+        const donePromise = new Promise((r) => { resolveDone = r; });
+        const handleSubmit = async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            appendHistory(trimmed);
+            if (trimmed === '/exit' || trimmed === '/quit') {
+                done = true;
+                if (resolveDone)
+                    resolveDone();
+                return;
+            }
+            if (trimmed === '/help' || trimmed === '/skills') {
+                printHelp();
+                return;
+            }
+            // /files — open interactive picker for .cspeach.json artefacts in
+            // the workspace folder. After picking a file and an action, prints
+            // the synthesized slash command for the user to copy or recall.
+            if (trimmed === '/files') {
+                try {
+                    const { openFilePicker } = await import('./repl/file-picker.js');
+                    const result = await openFilePicker();
+                    if (result.kind === 'command') {
+                        chunkEmitter.emit('chunk', chalk.dim(`↪ ${result.command}\n`));
+                    }
+                    else if (result.kind === 'empty') {
+                        // Empty workspace — print the listing so the user sees the
+                        // workspace path and the "drop something here" hint. Skipped
+                        // on 'cancelled' so a cancel returns silently to the prompt.
+                        const { listProjectFiles, ensureWorkspace, formatProjectFileList } = await import('./projects/workspace.js');
+                        const ws = await ensureWorkspace();
+                        const files = await listProjectFiles();
+                        chunkEmitter.emit('chunk', formatProjectFileList(files, ws) + '\n');
+                    }
+                    // result.kind === 'cancelled' — print nothing.
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[/files] ${err.message}\n`));
+                }
+                return;
+            }
+            // /ui — view or change rendering mode. Ink-mode branch mirrors non-Ink.
+            if (trimmed === '/ui' || trimmed.startsWith('/ui ')) {
+                // Defensive: a config that predates the [ui] section may have cfg.ui === undefined
+                // if loaded before loader.ts's deep-merge fix. Initialise to the default.
+                if (!cfg.ui)
+                    cfg.ui = { rendering: 'auto' };
+                const arg = trimmed.slice(3).trim().toLowerCase();
+                if (arg === '') {
+                    console.log(`\nCurrent UI mode: ${chalk.cyan.bold(cfg.ui.rendering)}  ` +
+                        `(effective now: ${chalk.yellow(shouldUseInk() ? 'ink' : 'classic')})\n`);
+                    console.log(chalk.dim('  /ui classic  — chalk REPL (default)'));
+                    console.log(chalk.dim('  /ui ink      — Ink frame (opt-in)'));
+                    console.log(chalk.dim('  /ui auto     — choose automatically\n'));
+                    console.log(chalk.dim('Change takes effect after /exit + relaunch.\n'));
+                }
+                else if (arg === 'auto' || arg === 'ink' || arg === 'classic') {
+                    cfg.ui.rendering = arg;
+                    try {
+                        await saveConfig(cfg);
+                        console.log(chalk.green(`\n✓ UI mode set to ${chalk.bold(arg)}.`));
+                        console.log(chalk.dim('Relaunch cspeach to apply.\n'));
+                    }
+                    catch (err) {
+                        console.log(chalk.red(`\n✗ Failed to save config: ${err.message}\n`));
+                    }
+                }
+                else {
+                    console.log(chalk.red(`\nUnknown UI mode: ${arg}. Try auto / ink / classic.\n`));
+                }
+                return;
+            }
+            // /reroute — re-dispatch session.lastUserPrompt to a different skill
+            if (trimmed === '/reroute' || trimmed.startsWith('/reroute ')) {
+                session.awaitingSkillAnswer = false;
+                const rr = parseAndValidateReroute(trimmed, session.lastUserPrompt, SKILL_CATALOG);
+                if (rr.kind === 'error') {
+                    console.log(chalk.red(`\n${rr.message}\n`));
+                    return;
+                }
+                const preview = rr.prompt.length > 60 ? rr.prompt.slice(0, 57) + '...' : rr.prompt;
+                console.log(chalk.dim(`↪ Rerouting "${preview}" → /${rr.skill}`));
+                if (rr.warning)
+                    console.log(chalk.dim(`  (${rr.warning})`));
+                await runTurn({
+                    provider,
+                    userMessage: rr.prompt,
+                    skill: rr.skill,
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    chunkEmitter,
+                });
+                return;
+            }
+            // /new — clear any "awaiting skill answer" state so the next prompt
+            // goes through the classifier afresh instead of auto-continuing the
+            // previous skill's Q&A chain.
+            if (trimmed === '/new' || trimmed === '/reset') {
+                session.awaitingSkillAnswer = false;
+                console.log(chalk.dim('↩ fresh start — next prompt will be classified normally'));
+                return;
+            }
+            // /transport — session current-transport state for Rule 9 (transport isolation)
+            if (trimmed === '/transport' || trimmed.startsWith('/transport ')) {
+                const arg = trimmed === '/transport' ? '' : trimmed.slice('/transport '.length);
+                const msg = handleTransportCommand(arg);
+                console.log(chalk.cyan(msg));
+                return;
+            }
+            const parsed = parseShortcut(trimmed);
+            // Record the prose body (post-shortcut stripping) for /reroute. Using
+            // `parsed.prompt` rather than `trimmed` means:
+            //   - plain prose: `parsed.prompt === trimmed`, stored as-is
+            //   - `/radar look at ZFOO`: stored as `look at ZFOO` — a later /reroute
+            //     replays the body with a new skill (correct)
+            //   - `@ZCL_ORDER explain this`: stored as `explain this` — @OBJECT
+            //     context is lost on reroute, acceptable v0.3.1 limitation
+            session.lastUserPrompt = parsed.prompt;
+            const prompt = parsed.prompt;
+            const extractedObject = parsed.object ?? null;
+            const previousSkill = session.skill;
+            const previousObject = session.last_object ?? null;
+            const shortcutSkill = parsed.skill;
+            let skill = shortcutSkill;
+            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
+                // as brand-new prompts. Type /new to opt out.
+                // Use session.skill (the skill of the IMMEDIATELY PREVIOUS turn) —
+                // NOT session.last_skill which holds the skill from TWO turns ago
+                // and is used as classifier context.
+                if ((session.awaitingSkillAnswer || isAckContinuation(trimmed, session.skill)) && session.skill) {
+                    chunkEmitter.emit('chunk', chalk.dim(`↪ Continuing /${session.skill}\n`));
+                    skill = session.skill;
+                }
+                else if (isBareAck(trimmed)) {
+                    // Bare "y" / "n" / "cancel" with no skill to continue — typing this
+                    // after an aborted turn is almost always a stray keystroke, NOT a
+                    // request to start work. Don't burn a classifier round-trip on it.
+                    chunkEmitter.emit('chunk', chalk.dim('↩ no active skill — type /help or a full prompt\n'));
+                    return;
+                }
+                else {
+                    try {
+                        const c = await classifyPrompt(prompt, {
+                            sap_system: selectedAlias,
+                            last_skill: session.last_skill ?? null,
+                            last_object: extractedObject ?? session.last_object ?? null,
+                        });
+                        const decision = decideRouting(c);
+                        let pickedResult;
+                        if (cfg.classifier.safe_mode) {
+                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(c, trimmed, false));
+                        }
+                        else if (decision.kind === 'silent') {
+                            chunkEmitter.emit('chunk', chalk.dim(`┄ Routed to /${decision.skill}\n`));
+                            pickedResult = decision.skill;
+                        }
+                        else if (decision.kind === 'coach') {
+                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, true));
+                        }
+                        else {
+                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, false));
+                        }
+                        if (pickedResult === PICK_CANCELLED) {
+                            chunkEmitter.emit('chunk', chalk.dim('↩ cancelled — type a new prompt\n'));
+                            return;
+                        }
+                        skill = pickedResult;
+                    }
+                    catch (err) {
+                        chunkEmitter.emit('chunk', chalk.red(`\n[classifier error] ${err.message}\n`));
+                        return;
+                    }
+                }
+            }
+            else {
+                // Explicit slash-shortcut → user is naming a skill, so clear any
+                // pending "awaiting answer" state from a prior turn.
+                session.awaitingSkillAnswer = false;
+            }
+            // D3 — `--status @file ...` is a one-shot pass-through that reads
+            // `.cspeach.json` envelopes from disk and prints a summary. Wired for
+            // /abap-spec-gap, /abap-design, and /abap-estimate (the renderer in
+            // projects/status.ts handles all three artefact types). It must NOT
+            // consume model tokens, so we intercept here AFTER skill resolution
+            // but BEFORE runTurn. The body lives in `prompt` (post-parseShortcut),
+            // e.g. `--status @./foo.cspeach.json`.
+            if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate') &&
+                /(^|\s)--status(\s|$)/.test(prompt)) {
+                try {
+                    const files = prompt
+                        .split(/\s+/)
+                        .filter((tok) => tok.startsWith('@'))
+                        .map((tok) => tok.slice(1));
+                    const { runSpecGapStatus } = await import('./commands/spec-gap-status.js');
+                    await runSpecGapStatus({
+                        files,
+                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                    });
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[--status] ${err.message}\n`));
+                }
+                session.last_skill = previousSkill ?? null;
+                session.last_object = extractedObject ?? previousObject ?? null;
+                return;
+            }
+            try {
+                await runTurn({
+                    provider,
+                    userMessage: prompt,
+                    skill: skill,
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    chunkEmitter,
+                });
+            }
+            catch (err) {
+                const { emitError } = await import('./ui/error-emitter.js');
+                emitError({
+                    code: 'RUN_TURN_ERROR',
+                    title: 'Turn failed',
+                    body: err.message,
+                });
+            }
+            session.last_skill = previousSkill ?? null;
+            session.last_object = extractedObject ?? previousObject ?? null;
+            // 2026-05-08: post-turn auto-dispatch. The dispatch_skill tool may
+            // have queued a slash command (typically after the user picked
+            // "Switch to /abap-X" via ask_question). Consume the slot and
+            // re-enter handleSubmit with that command — no user keypress.
+            // The user's consent was the picker pick.
+            const dispatched = pendingDispatchAccessor.get();
+            if (dispatched) {
+                pendingDispatchAccessor.set(null);
+                chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${dispatched}\n`));
+                // Schedule on next tick so the current handleSubmit's promise
+                // resolves cleanly before the next one starts. Recursion via
+                // setImmediate keeps the call stack flat across long chains.
+                setImmediate(() => { void handleSubmit(dispatched); });
+            }
+        };
+        const { unmount } = render(React.createElement(App, {
+            chunkEmitter,
+            onSubmit: (line) => { void handleSubmit(line); },
+            onSlashTrigger: () => { },
+            onHistoryTrigger: () => { },
+            getToolCalls: () => session.toolCalls,
+            writeMode: cfg.write_mode,
+        }));
+        await donePromise;
+        unmount();
+        return 0;
+    }
+    // --- readline setup (replaces inquirer input()) ---
+    //
+    // Bracketed-paste: by default readline splits input at every `\n`, so a
+    // multi-line paste loses every line after the first. We turn on DEC
+    // mode 2004 on the terminal and pipe stdin through a decoder that
+    // collapses the content between `\x1b[200~` / `\x1b[201~` markers into
+    // a single line before readline sees it. See src/repl/bracketed-paste.ts.
+    enableBracketedPaste();
+    const pasteInput = new BracketedPasteDecoder();
+    process.stdin.pipe(pasteInput);
+    const history = loadHistory();
+    const rl = readline.createInterface({
+        input: pasteInput,
+        output: process.stdout,
+        terminal: true,
+        historySize: HISTORY_SIZE,
+        removeHistoryDuplicates: true,
+        history, // seed with persisted history from previous sessions
+        // 2026-05-01: Tab-completion for slash commands. readline's native
+        // completer fires on Tab — type `/abap-r<Tab>` and it expands to the
+        // matching skill, or shows the filtered list if multiple. Type `/<Tab>`
+        // for the full skill + built-in command catalogue. Non-slash lines get
+        // no completion so natural prose isn't disturbed.
+        //
+        // 2026-05-06: extended to also Tab-complete `@<filename>` tokens
+        // against the workspace folder. atCompleter returns null for non-@
+        // lines and we fall through to slashCompleter — both completers
+        // coexist without stepping on each other.
+        completer: (line) => atCompleter(line) ?? slashCompleter(line),
+    }); // 'history' seed is supported at runtime but not in @types/node yet
+    // Disable bracketed paste on shutdown so the user's shell prompt after
+    // CSPeach exits doesn't keep receiving wrapped pastes.
+    process.on('exit', () => disableBracketedPaste());
+    // Prompt string: 'CSPeach ' + '›' in peach colour
+    const promptStr = 'CSPeach ' + chalk.hex(PEACH)('›') + ' ';
+    // When we dispatch an inquirer sub-prompt (coaching picker, pickSkill),
+    // readline is paused to give inquirer exclusive stdin access. On resolve
+    // inquirer sometimes disturbs the stdin stream in a way that makes our
+    // readline fire 'close' even though the user did NOT press Ctrl-D. Suppress
+    // the exit in that window — real EOF still exits via the catch in the
+    // question() loop below.
+    let suppressRlClose = false;
+    // Tracks the most recent slash-command head we pre-filled with no
+    // body. If the user submits the same head twice in a row with no
+    // body, we treat the second submit as "cancel" and clear the line
+    // instead of re-prompting. Reset to null on any non-empty submit.
+    let lastEmptyPrefill = null;
+    // Pre-fill state for the next prompt. When the user picks a slash
+    // command from the picker (or types a bare slash command), we set
+    // this so the next rl.question prints `CSPeach › /<cmd> ` and the
+    // user types the body after it. Consumed (cleared + prepended onto
+    // line) on every submit. Also cleared by Esc handler below.
+    let pendingPrefill = '';
+    // 2026-05-08: per-picker guards. Each tracks the exact line that just
+    // had THAT picker cancelled — the next iteration skips re-firing the
+    // SAME picker on the SAME line, but lets the OTHER picker still fire
+    // if its trigger condition is met. Initially conflated into one
+    // shared flag, which produced this bug:
+    //   - Iter 1: at-picker cancelled on "X"; flag = "X".
+    //   - Iter 2: slash-picker check (different concern) reset the flag.
+    //   - Iter 2: at-picker check then fires because flag is now null.
+    // Splitting into two flags keeps each picker's cancel state
+    // independent. Reset by submitting any line different from the one
+    // just cancelled.
+    let lastCancelledSlashLine = null;
+    let lastCancelledAtLine = null;
+    // v0.6 — module-scope flag the per-turn SIGINT handler sets to true while
+    // a turn is in flight. Both `rl.on('close')` and `rl.on('SIGINT')` below
+    // check this flag and bail out so they don't race against the turn-scoped
+    // handler that wants to abort the LLM stream and render "✋ Turn cancelled."
+    // Without this flag, Ctrl+C during a stream lands in the readline SIGINT
+    // path first (line buffer is empty during streaming → "Goodbye" + exit),
+    // killing the CLI before the turn handler can do anything useful.
+    let turnInProgress = false;
+    rl.on('close', () => {
+        if (suppressRlClose)
+            return;
+        if (turnInProgress)
+            return; // turn handler owns the abort + UX
+        console.log('\nGoodbye.\n');
+        process.exit(0);
+    });
+    // 2026-05-08: handle Ctrl+C explicitly. Without a 'SIGINT' listener
+    // Node's readline default fires — which closes the readline. That is
+    // what made Ctrl+C inside an inquirer sub-prompt (file picker, skill
+    // picker, approval) drop the user back to the shell with a "Goodbye"
+    // even though inquirer had already cleanly cancelled the sub-prompt.
+    // The mere presence of this listener suppresses Node's default close.
+    //
+    // Semantic (refined 2026-05-08 after live feedback "we cannot escape
+    // from here"): the empty-prompt case is the user trying to leave. The
+    // line-has-content case is the user trying to clear what they typed.
+    //   - Empty prompt + Ctrl+C  → exit cleanly (Goodbye)
+    //   - Non-empty prompt + Ctrl+C → clear current line, redraw prompt
+    //   - Inquirer sub-prompt + Ctrl+C → cancel that sub-prompt only
+    //     (inquirer's own SIGINT handler throws; this listener returns
+    //      early so we don't ALSO close readline behind it)
+    //   - Ctrl+D / /exit / /quit → exit cleanly (existing paths)
+    rl.on('SIGINT', () => {
+        if (suppressRlClose)
+            return;
+        // v0.6 — turn-scoped SIGINT handler (registered just before runTurn
+        // and torn down right after) takes precedence. If a turn is in flight,
+        // the user wants to interrupt THE TURN, not exit the CLI. Returning
+        // early lets the turn handler run its abort + "✋ Turn cancelled." UX.
+        if (turnInProgress)
+            return;
+        // Inspect the readline's internal line buffer + our prefill state.
+        // Both empty → user is at a blank prompt and wants out. Either has
+        // content → user wants to clear what they typed.
+        const currentLine = rl.line ?? '';
+        const isEmpty = currentLine.length === 0 && pendingPrefill.length === 0;
+        if (isEmpty) {
+            console.log('\nGoodbye.\n');
+            rl.close();
+            process.exit(0);
+        }
+        process.stdout.write('\n');
+        pendingPrefill = '';
+        rl
+            .write(null, { ctrl: true, name: 'u' });
+        rl.prompt();
+    });
+    // 2026-05-02: bind bare Esc → clear-line. Listen on process.stdin
+    // DIRECTLY rather than on the pasteInput stream — bracketed-paste
+    // decoder holds bytes that are prefixes of paste markers, including
+    // a bare 0x1B (since `\x1b[200~` starts with 0x1B). A 50ms flush
+    // timer was meant to release the byte but in practice the timer's
+    // push out of the Transform doesn't always re-trigger emitKeypress
+    // on downstream consumers. Listening directly on process.stdin
+    // bypasses the decoder entirely for keypress detection — the
+    // raw byte arrives, we parse it, and we act on it. The decoder
+    // still processes the same byte for readline's data path; the
+    // duplicate read is harmless because readline ignores bare Esc.
+    //
+    // Skipped while inquirer is active: inquirer takes over stdin in
+    // raw mode and owns Esc semantics. The suppressRlClose flag is set
+    // by inquirer-guard before any sub-prompt opens.
+    // 2026-05-02: detect bare Esc by raw byte rather than keypress event.
+    // The keypress event chain (emitKeypressEvents → 'keypress' on
+    // process.stdin OR pasteInput) was unreliable here — the bracketed-
+    // paste decoder buffers prefix-of-marker bytes (Esc is a strict
+    // prefix of `\x1b[200~`), and the alternate stdin-listener path
+    // didn't fire either. Direct byte inspection on stdin is the most
+    // reliable surface: a single-byte chunk equal to 0x1B is a bare Esc.
+    // Multi-byte chunks (arrow keys, paste markers) arrive together and
+    // start with 0x1B but include follow-up bytes, so we can distinguish
+    // them by chunk.length and skip those.
+    //
+    // Caveat on chunk boundaries: terminals occasionally split escape
+    // sequences across chunks. To guard against false-positives, we wait
+    // a short window after seeing a lone 0x1B; if a follow-up byte
+    // arrives within that window, the original is part of a sequence
+    // and we don't act. If not, it was a deliberate Esc.
+    let escWaitTimer = null;
+    const handleBareEscape = () => {
+        if (suppressRlClose)
+            return;
+        const rlWrite = rl.write;
+        // Clear the editable buffer (everything typed after the prefill).
+        rlWrite.call(rl, null, { ctrl: true, name: 'u' });
+        if (pendingPrefill) {
+            // 2026-05-02: { name: 'return' } via rl.write does NOT reliably
+            // trigger readline's _line() — depending on Node version the
+            // key handler ignores it. Most direct way to force the current
+            // rl.question() to resolve is to emit the 'line' event on rl
+            // manually with an empty string. That fires the question's
+            // internal callback, the awaited promise resolves with '', and
+            // the loop iterates to redraw a clean prompt.
+            pendingPrefill = '';
+            setImmediate(() => {
+                rl.emit('line', '');
+            });
+        }
+    };
+    // 2026-05-02: stdin 'data' listener for bare-Esc detection. Inquirer
+    // (search picker / approval / safety prompts) strips data listeners
+    // on release, so we cannot rely on a one-time attach — the listener
+    // would silently disappear after the first picker open. Wrap the
+    // attach logic in a function and call it both initially AND at the
+    // top of every REPL iteration. Each call removes any previous copy
+    // of OUR listener (so we don't accumulate over time) and re-adds it.
+    const debugEsc = process.env['CSPEACH_DEBUG_ESC'] === '1';
+    const escDataListener = (chunk) => {
+        if (debugEsc) {
+            const hex = Array.from(chunk).slice(0, 8).map((b) => b.toString(16).padStart(2, '0')).join(' ');
+            process.stderr.write(`\n[stdin] len=${chunk.length} bytes=${hex}${chunk.length > 8 ? '...' : ''}\n`);
+        }
+        if (escWaitTimer && (chunk.length > 1 || chunk[0] !== 0x1B)) {
+            if (debugEsc)
+                process.stderr.write('[stdin] cancelling pending esc-wait (follow-up byte)\n');
+            clearTimeout(escWaitTimer);
+            escWaitTimer = null;
+        }
+        if (chunk.length === 1 && chunk[0] === 0x1B && !escWaitTimer) {
+            if (debugEsc)
+                process.stderr.write('[stdin] arming esc-wait timer\n');
+            escWaitTimer = setTimeout(() => {
+                escWaitTimer = null;
+                if (debugEsc)
+                    process.stderr.write('[stdin] esc confirmed, firing handler\n');
+                handleBareEscape();
+            }, 30);
+            escWaitTimer.unref?.();
+        }
+    };
+    const attachEscDetector = () => {
+        // Attach to BOTH process.stdin and pasteInput. Inquirer prompts
+        // strip listeners from process.stdin on release, so a stdin-only
+        // listener silently breaks after the first sub-prompt. pasteInput
+        // is OUR transform stream that inquirer doesn't touch — listening
+        // there is a robust fallback. Either listener firing triggers the
+        // same handler; the duplicate is harmless because the timer arms
+        // only once per chunk.
+        process.stdin.removeListener('data', escDataListener);
+        process.stdin.on('data', escDataListener);
+        pasteInput.removeListener('data', escDataListener);
+        pasteInput.on('data', escDataListener);
+        if (debugEsc) {
+            process.stderr.write(`[attach] stdin listeners=${process.stdin.listenerCount('data')} ` +
+                `pasteInput listeners=${pasteInput.listenerCount('data')} ` +
+                `stdin paused=${process.stdin.isPaused?.() ?? 'n/a'}\n`);
+        }
+    };
+    attachEscDetector();
+    // Register the main readline with the inquirer-guard so any tool handler
+    // (ask_question, request_approval, …) that opens an inquirer sub-prompt
+    // can pause us and suppress the spurious 'close' inquirer emits on
+    // release. See src/repl/inquirer-guard.ts for the failure mode this
+    // prevents (CSPeach silently exiting after a tool-mediated prompt).
+    registerReadline(rl, (v) => {
+        suppressRlClose = v;
+    });
+    // 2026-05-08: one-time workspace-default migration. The default workspace
+    // changed from `~/CSPeach/` to project-rooted `<git-root>/.cspeach/`.
+    // Existing users with files in ~/CSPeach/ get asked once how to handle
+    // them. After that the flag is set and this becomes a no-op.
+    // Wrapped in withInquirer because it opens a select() sub-prompt.
+    await maybePromptWorkspaceMigration({
+        prompt: async ({ fileCount, oldWorkspace, newWorkspace }) => withInquirer(() => select({
+            message: `Found ${fileCount} file(s) in ${oldWorkspace}. CSPeach now defaults to project-rooted workspaces — what should we do?`,
+            default: 'move',
+            choices: [
+                { value: 'move', name: `Move all to ${newWorkspace} (recommended for this project)` },
+                { value: 'keep_global', name: `Keep using ${oldWorkspace} as global workspace (pins config workspace_folder)` },
+                { value: 'leave', name: `Leave ${oldWorkspace} alone — start fresh in ${newWorkspace}` },
+            ],
+        })),
+        log: (line) => console.log(chalk.dim(line)),
+    });
+    while (true) {
+        // Re-attach the bare-Esc detector every iteration. Inquirer prompts
+        // (slash-picker, approval, ask_question, safety-confirm) remove
+        // listeners on release; without this re-attach Esc detection
+        // silently breaks after the first sub-prompt.
+        attachEscDetector();
+        let line;
+        // 2026-05-08: pre-prompt auto-dispatch. If the previous turn's
+        // dispatch_skill tool queued a slash command, skip the rl.question
+        // wait and feed that command to the loop directly — the user's
+        // consent was the picker pick, no Enter required. Cleared
+        // immediately so a stale value never re-fires.
+        const dispatchedCmd = pendingDispatchAccessor.get();
+        if (dispatchedCmd) {
+            pendingDispatchAccessor.set(null);
+            console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
+            line = dispatchedCmd;
+        }
+        else {
+            const effectivePrompt = pendingPrefill ? promptStr + pendingPrefill : promptStr;
+            try {
+                line = await rl.question(effectivePrompt);
+            }
+            catch {
+                // rl.question rejects for two distinct reasons:
+                //  1. readline genuinely closed (real EOF / Ctrl+D / rl.close()
+                //     called) → exit cleanly with the standard goodbye.
+                //  2. transient AbortError when a SIGINT bubbled up after an
+                //     inquirer sub-prompt consumed Ctrl+C. The readline is still
+                //     alive, the user just wanted to cancel the current line —
+                //     redraw the prompt and continue the loop.
+                // The 'closed' property on Node's readline interface (Node 18+)
+                // discriminates the two cases reliably.
+                const rlAny = rl;
+                if (rlAny.closed) {
+                    console.log('\nGoodbye.\n');
+                    rl.close();
+                    return 0;
+                }
+                pendingPrefill = '';
+                continue;
+            }
+        }
+        // If a pre-fill was active, prepend it onto the user-typed body
+        // to recover the full command. Then clear the pre-fill — it's a
+        // one-shot signal, consumed on the next submit.
+        if (pendingPrefill) {
+            line = pendingPrefill + line;
+            pendingPrefill = '';
+        }
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Persist non-empty input to history file.
+        appendHistory(trimmed);
+        // 2026-05-01 fix: rl.question() does NOT auto-populate readline's internal
+        // history (only the 'line' event does). Without this manual push, arrow-up
+        // cycles only through the file-loaded seed from session start — commands
+        // typed THIS session never appear. Push to the front, trim to historySize,
+        // and skip exact-dup-of-most-recent so the buffer stays clean.
+        const rlHistory = rl.history;
+        if (Array.isArray(rlHistory)) {
+            if (rlHistory[0] !== trimmed)
+                rlHistory.unshift(trimmed);
+            if (rlHistory.length > HISTORY_SIZE)
+                rlHistory.length = HISTORY_SIZE;
+        }
+        // /cancel — the reliable way to escape a pre-filled slash command.
+        // Works in two contexts:
+        //   1. Standalone: user is at a clean prompt and types `/cancel` —
+        //      no-op except for a tiny hint that there's nothing to cancel.
+        //   2. After a pre-fill: user is at `CSPeach › /abap-design ` and
+        //      types `/cancel` as the body. After pendingPrefill prepends,
+        //      the line ends with ` /cancel` — we detect that pattern and
+        //      treat it as "abandon the pre-fill, return to clean prompt".
+        //
+        // Esc would be the natural shortcut for this, but the bracketed-
+        // paste pipe + inquirer's stdin handling on Windows interferes
+        // with detecting bare-Esc reliably. /cancel is the cross-terminal
+        // fallback that always works.
+        if (trimmed === '/cancel') {
+            console.log(chalk.dim('Nothing to cancel — type a prompt or pick a command with /'));
+            continue;
+        }
+        if (trimmed.endsWith(' /cancel')) {
+            console.log(chalk.dim('↩ cancelled'));
+            continue;
+        }
+        if (trimmed === '/exit' || trimmed === '/quit') {
+            console.log('Goodbye.\n');
+            rl.close();
+            return 0;
+        }
+        // /help and /skills show the skill catalog flat-list.
+        if (trimmed === '/help' || trimmed === '/skills') {
+            printHelp();
+            continue;
+        }
+        // /files — open interactive picker for .cspeach.json artefacts in
+        // the workspace folder. After picking a file and an action, pre-fill
+        // the synthesized slash command into the NEXT prompt via pendingPrefill
+        // (the same mechanism Laeeq's slash-pre-fill uses) so the user just
+        // presses Enter to run it. Editing before Enter is supported — user
+        // can append flags or change the command head.
+        //
+        // Earlier revision used rl.history.unshift to stage the command for
+        // up-arrow recall, which silently failed (history-array writes don't
+        // surface to the next up-arrow press in this readline configuration).
+        // pendingPrefill is the proven path — it bakes the line into the
+        // prompt string itself so there's no race with readline's redraw.
+        if (trimmed === '/files') {
+            try {
+                const { openFilePicker } = await import('./repl/file-picker.js');
+                const result = await openFilePicker();
+                if (result.kind === 'command') {
+                    console.log(chalk.dim(`↪ Picked. Press Enter to run, or edit first.`));
+                    pendingPrefill = result.command;
+                }
+                else if (result.kind === 'empty') {
+                    // Empty workspace — print the listing so the user sees the
+                    // workspace path and the "drop something here" hint. Skipped
+                    // on 'cancelled' so a cancel returns silently to the prompt.
+                    const { listProjectFiles, ensureWorkspace, formatProjectFileList } = await import('./projects/workspace.js');
+                    const ws = await ensureWorkspace();
+                    const files = await listProjectFiles();
+                    console.log(formatProjectFileList(files, ws));
+                }
+                // result.kind === 'cancelled' — print nothing.
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[/files] ${err.message}\n`));
+            }
+            continue;
+        }
+        // /ui — view or change the rendering mode. Takes effect on next launch.
+        if (trimmed === '/ui' || trimmed.startsWith('/ui ')) {
+            // Defensive: a config that predates the [ui] section may have cfg.ui === undefined
+            // if loaded before loader.ts's deep-merge fix. Initialise to the default.
+            if (!cfg.ui)
+                cfg.ui = { rendering: 'auto' };
+            const arg = trimmed.slice(3).trim().toLowerCase();
+            if (arg === '') {
+                console.log(`\nCurrent UI mode: ${chalk.cyan.bold(cfg.ui.rendering)}  ` +
+                    `(effective now: ${chalk.yellow(shouldUseInk() ? 'ink' : 'classic')})\n`);
+                console.log(chalk.dim('  /ui classic  — chalk REPL (v0.2 style — default, fully tested)'));
+                console.log(chalk.dim('  /ui ink      — Ink frame (v0.3 — opt-in while polish is pending)'));
+                console.log(chalk.dim('  /ui auto     — choose automatically based on terminal'));
+                console.log(chalk.dim('\nChanges are written to ~/.cspeach/config.toml and'));
+                console.log(chalk.dim('take effect the next time you launch cspeach.\n'));
+            }
+            else if (arg === 'auto' || arg === 'ink' || arg === 'classic') {
+                cfg.ui.rendering = arg;
+                try {
+                    await saveConfig(cfg);
+                    console.log(chalk.green(`\n✓ UI mode set to ${chalk.bold(arg)}.`));
+                    console.log(chalk.dim('Relaunch cspeach (`/exit` then `cspeach`) to apply.\n'));
+                }
+                catch (err) {
+                    console.log(chalk.red(`\n✗ Failed to save config: ${err.message}\n`));
+                }
+            }
+            else {
+                console.log(chalk.red(`\nUnknown UI mode: ${arg}. Try auto / ink / classic.\n`));
+            }
+            continue;
+        }
+        // /reroute — re-dispatch session.lastUserPrompt to a different skill
+        if (trimmed === '/reroute' || trimmed.startsWith('/reroute ')) {
+            session.awaitingSkillAnswer = false;
+            const rr = parseAndValidateReroute(trimmed, session.lastUserPrompt, SKILL_CATALOG);
+            if (rr.kind === 'error') {
+                console.log(chalk.red(`\n${rr.message}\n`));
+                continue;
+            }
+            const preview = rr.prompt.length > 60 ? rr.prompt.slice(0, 57) + '...' : rr.prompt;
+            console.log(chalk.dim(`↪ Rerouting "${preview}" → /${rr.skill}`));
+            if (rr.warning)
+                console.log(chalk.dim(`  (${rr.warning})`));
+            await runTurn({
+                provider,
+                userMessage: rr.prompt,
+                skill: rr.skill,
+                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+            });
+            continue;
+        }
+        // /new — clear "awaiting skill answer" state so the next prompt is
+        // classified afresh instead of continuing the previous skill's Q&A chain.
+        if (trimmed === '/new' || trimmed === '/reset') {
+            session.awaitingSkillAnswer = false;
+            console.log(chalk.dim('↩ fresh start — next prompt will be classified normally'));
+            continue;
+        }
+        // /transport — session current-transport state for Rule 9 (transport isolation)
+        if (trimmed === '/transport' || trimmed.startsWith('/transport ')) {
+            const arg = trimmed === '/transport' ? '' : trimmed.slice('/transport '.length);
+            const msg = handleTransportCommand(arg);
+            console.log(chalk.cyan(msg));
+            continue;
+        }
+        // 2026-05-01: live slash-command picker. When the user types something
+        // that LOOKS like a slash command but isn't an exact match — `/`,
+        // `/abap-r`, `/fix`, etc. — open a search-as-you-type picker
+        // pre-filtered to whatever they typed. Replaces the Tab-cycle
+        // autocomplete which scrolled by command names rather than letting
+        // the user filter and arrow-key through them. An exact match (like
+        // `/abap-refactor` or `/abap-refactor look at ZFOO`) skips the
+        // picker and runs through the existing routing.
+        let resolvedTrimmed = trimmed;
+        if (trimmed.startsWith('/') && !isExactSlashMatch(trimmed)) {
+            if (lastCancelledSlashLine === trimmed) {
+                // 2026-05-08: identical resubmit after cancel = user wants to
+                // drop the line entirely (cancel really means cancel). Clear
+                // the prefilled buffer so iter 3 starts fresh, clear the
+                // guard, and skip dispatch.
+                lastCancelledSlashLine = null;
+                console.log(chalk.dim('↩ dropped'));
+                process.nextTick(() => prefillReadline(rl, ''));
+                continue;
+            }
+            // Extract the head after the slash, drop any arguments. Picker
+            // filters on this; once user picks, we re-attach the arguments.
+            const headEnd = trimmed.search(/\s/);
+            const head = headEnd === -1 ? trimmed : trimmed.slice(0, headEnd);
+            const rest = headEnd === -1 ? '' : trimmed.slice(headEnd);
+            const prefix = head.slice(1); // drop the leading /
+            const picked = await openSlashPicker(prefix);
+            if (picked === null) {
+                console.log(chalk.dim('↩ cancelled — edit, or press Enter again to drop'));
+                lastCancelledSlashLine = trimmed;
+                process.nextTick(() => prefillReadline(rl, trimmed));
+                continue;
+            }
+            lastCancelledSlashLine = null;
+            resolvedTrimmed = `/${picked}${rest}`;
+        }
+        else if (lastCancelledSlashLine !== null && lastCancelledSlashLine !== trimmed) {
+            // User edited the previously-cancelled line into something
+            // different — re-arm the slash-picker for future cancels.
+            lastCancelledSlashLine = null;
+        }
+        // 2026-05-08: live `@<filename>` picker. When the user submits a line
+        // ending in a partial / unresolved @-token (e.g. `/abap-rap --from @`
+        // or `/abap-rap --from @b9b`), open a search-as-you-type picker
+        // pre-filtered to whatever they typed. Mirrors the slash-picker
+        // pattern. Tab still works (atCompleter) for users who prefer a
+        // quick list without screen takeover; this picker is for Enter.
+        {
+            const atPrefix = pendingAtTokenPrefix(resolvedTrimmed);
+            if (atPrefix !== null) {
+                if (lastCancelledAtLine === resolvedTrimmed) {
+                    // 2026-05-08: identical resubmit after cancel = drop entirely.
+                    // Without this the line went to the LLM with a bare/partial
+                    // @ — wasted a turn and confused the user who'd just cancelled.
+                    lastCancelledAtLine = null;
+                    console.log(chalk.dim('↩ dropped'));
+                    process.nextTick(() => prefillReadline(rl, ''));
+                    continue;
+                }
+                const pickedFile = await openAtPicker(atPrefix);
+                if (pickedFile === null) {
+                    console.log(chalk.dim('↩ cancelled — edit, or press Enter again to drop'));
+                    lastCancelledAtLine = resolvedTrimmed;
+                    process.nextTick(() => prefillReadline(rl, resolvedTrimmed));
+                    continue;
+                }
+                lastCancelledAtLine = null;
+                // Substitute the rightmost @<prefix> with the picked filename.
+                resolvedTrimmed = resolvedTrimmed.replace(/@\S*$/, `@${pickedFile}`);
+            }
+            else if (lastCancelledAtLine !== null && lastCancelledAtLine !== resolvedTrimmed) {
+                // User edited the previously-cancelled at-line into something
+                // different — re-arm the at-picker for future cancels.
+                lastCancelledAtLine = null;
+            }
+        }
+        // 2026-05-01: a bare slash command with no body (e.g. just
+        // `/abap-design`) used to dispatch with an empty prompt, which
+        // the LLM API rejects as "messages.0: user messages must have
+        // non-empty content". Detect this case and pre-fill readline
+        // with `<command> ` (trailing space) so the user can keep
+        // typing their actual prompt. Built-in commands (/exit, /help,
+        // /transport, etc.) already returned earlier — this only
+        // catches skill routes.
+        //
+        // 2026-05-02: simplified — the only way to escape a pre-fill is
+        // Esc / Ctrl+U / Ctrl+C. Pressing Enter without adding a body
+        // just re-prints the hint and re-fills (no destructive cancel).
+        // Pressing Enter twice used to clear, but users expected Enter
+        // to be a no-op when there's nothing to submit, so the
+        // double-Enter cancel was confusing.
+        if (resolvedTrimmed.startsWith('/')) {
+            const splitIdx = resolvedTrimmed.search(/\s/);
+            const bodyAfter = splitIdx === -1 ? '' : resolvedTrimmed.slice(splitIdx).trim();
+            if (bodyAfter.length === 0) {
+                const head = splitIdx === -1 ? resolvedTrimmed : resolvedTrimmed.slice(0, splitIdx);
+                // Show hint only on the FIRST pre-fill of this command. If the
+                // user re-submits the empty pre-fill, just silently re-fill
+                // without re-spamming the hint line. Tracked via lastEmptyPrefill.
+                if (lastEmptyPrefill !== head) {
+                    console.log(chalk.dim(`↪ ${head} — type your prompt and press Enter ` +
+                        chalk.dim(`(or "/cancel" to abandon)`)));
+                    lastEmptyPrefill = head;
+                }
+                // 2026-05-02: bake the pre-fill into the next prompt string
+                // instead of trying to seed the readline buffer post-hoc.
+                // Buffer manipulation (rl.write / direct line/cursor +
+                // _refreshLine) raced with rl.question's own prompt drawing
+                // and produced double prompts / cursor at start / typing
+                // wiping the command. Including the pre-fill in the prompt
+                // means readline only manages the body the user types after
+                // it — no race, no seeded buffer to lose.
+                pendingPrefill = `${head} `;
+                continue;
+            }
+        }
+        // Any non-empty submit clears the empty-prefill latch.
+        lastEmptyPrefill = null;
+        const parsed = parseShortcut(resolvedTrimmed);
+        // Record the prose body (post-shortcut stripping) for /reroute. Using
+        // `parsed.prompt` rather than `trimmed` means:
+        //   - plain prose: `parsed.prompt === trimmed`, stored as-is
+        //   - `/radar look at ZFOO`: stored as `look at ZFOO` — a later /reroute
+        //     replays the body with a new skill (correct)
+        //   - `@ZCL_ORDER explain this`: stored as `explain this` — @OBJECT
+        //     context is lost on reroute, acceptable v0.3.1 limitation
+        session.lastUserPrompt = parsed.prompt;
+        const prompt = parsed.prompt;
+        const extractedObject = parsed.object ?? null;
+        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) {
+            // 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
+            // as brand-new prompts. Type /new to opt out.
+            // Use session.skill (the skill of the IMMEDIATELY PREVIOUS turn) —
+            // NOT session.last_skill which holds the skill from TWO turns ago
+            // and is used as classifier context.
+            if ((session.awaitingSkillAnswer || isAckContinuation(trimmed, session.skill)) && session.skill) {
+                console.log(chalk.dim(`↪ Continuing /${session.skill}`));
+                skill = session.skill;
+            }
+            else if (isBareAck(trimmed)) {
+                // Bare "y" / "n" / "cancel" with no skill to continue — almost always
+                // a stray keystroke after an aborted turn, not a request to start
+                // work. Don't burn a classifier round-trip on it.
+                console.log(chalk.dim('↩ no active skill — type /help or a full prompt'));
+                continue;
+            }
+            else {
+                try {
+                    const c = await classifyPrompt(prompt, {
+                        sap_system: selectedAlias,
+                        last_skill: session.last_skill ?? null,
+                        last_object: extractedObject ?? session.last_object ?? null,
+                    });
+                    const decision = decideRouting(c);
+                    let pickedResult;
+                    // Coaching picker path — inquirer takes over stdin. Use the shared
+                    // withInquirer guard so the suppress-close window stays active
+                    // across the close-fire tick (inline guard cleared the flag
+                    // synchronously, leaking the close-fire and dropping CSPeach to
+                    // the shell mid-session).
+                    const runPicker = async (params) => {
+                        return withInquirer(() => coachingPickerClassic(params));
+                    };
+                    if (cfg.classifier.safe_mode) {
+                        // Safe mode overrides the decision — always open the full picker.
+                        pickedResult = await runPicker(buildCoachingParams(c, trimmed, false));
+                    }
+                    else if (decision.kind === 'silent') {
+                        console.log(chalk.dim(`┄ Routed to /${decision.skill}`));
+                        pickedResult = decision.skill;
+                    }
+                    else {
+                        const preSelect = decision.kind === 'coach';
+                        pickedResult = await runPicker(buildCoachingParams(decision.result, trimmed, preSelect));
+                    }
+                    if (pickedResult === PICK_CANCELLED) {
+                        console.log(chalk.dim('↩ cancelled — type a new prompt'));
+                        continue;
+                    }
+                    skill = pickedResult;
+                }
+                catch (err) {
+                    console.log(chalk.red(`\n[classifier error] ${err.message}`));
+                    continue;
+                }
+            }
+        }
+        else {
+            // Explicit slash-shortcut → user is naming a skill. Clear any pending
+            // "awaiting answer" state from a prior turn.
+            session.awaitingSkillAnswer = false;
+        }
+        // D3 — `--status @file ...` reads envelope files from disk and prints a
+        // status summary without invoking the model. Wired for /abap-spec-gap,
+        // /abap-design, and /abap-estimate (renderer in projects/status.ts is
+        // type-agnostic). Intercept after skill resolution, before runTurn. The
+        // prompt body (post-parseShortcut) looks like `--status @./foo.cspeach.json`.
+        if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate') &&
+            /(^|\s)--status(\s|$)/.test(prompt)) {
+            try {
+                const files = prompt
+                    .split(/\s+/)
+                    .filter((tok) => tok.startsWith('@'))
+                    .map((tok) => tok.slice(1));
+                const { runSpecGapStatus } = await import('./commands/spec-gap-status.js');
+                await runSpecGapStatus({
+                    files,
+                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                });
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[--status] ${err.message}\n`));
+            }
+            session.last_skill = previousSkill ?? null;
+            session.last_object = extractedObject ?? previousObject ?? null;
+            continue;
+        }
+        const turnStart = Date.now();
+        // H1 — `session.usage` is session-LIFETIME (initialised once in
+        // newSession, saved across turns). The footer's "this turn" label was
+        // misleading — it actually showed cumulative lifetime tokens. Snapshot
+        // the lifetime total BEFORE runTurn, then compute the per-turn delta
+        // after runTurn returns. This is Option A (per-turn local) — preferred
+        // over Option B (changing label to "lifetime") because users care about
+        // what the turn they just ran cost them, not the session running total.
+        const lifetimeTokensBefore = session.usage.input_tokens + session.usage.output_tokens;
+        // v0.6 — per-turn SIGINT hard-interrupt + AbortController.
+        //
+        // Critical: Node readline with `terminal: true` (which we use) puts
+        // stdin in raw mode. In raw mode, Ctrl+C is INTERCEPTED by readline
+        // and emitted as a 'SIGINT' event on the readline INSTANCE — no OS
+        // SIGINT signal reaches the process. So `process.on('SIGINT', ...)`
+        // would never fire here; we must listen on `rl` instead.
+        //
+        // Both rl listeners fire when Ctrl+C is pressed: the existing handler
+        // (above, line ~708) returns early because turnInProgress=true, and
+        // this turn-scoped handler does the actual abort + UX. Cleared in the
+        // finally so post-turn Ctrl+C falls back to the existing exit path.
+        turnInProgress = true;
+        const turnAbort = new AbortController();
+        let interruptedByUser = false;
+        let turnSigintFired = false;
+        const onSigint = () => {
+            if (turnSigintFired || turnAbort.signal.aborted)
+                return;
+            turnSigintFired = true;
+            interruptedByUser = true;
+            process.stderr.write(chalk.yellow('\n⚠  Interrupting turn — saving partial work...\n'));
+            turnAbort.abort();
+            // Remove ourselves so a SECOND Ctrl+C falls through to the
+            // existing rl SIGINT handler (which clears the line / exits) once
+            // turnInProgress flips back to false in the finally.
+            rl.removeListener('SIGINT', onSigint);
+        };
+        rl.on('SIGINT', onSigint);
+        try {
+            await runTurn({
+                provider,
+                userMessage: prompt,
+                skill: skill,
+                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                signal: turnAbort.signal,
+            });
+        }
+        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,
+                print: (line) => console.error(line),
+            });
+        }
+        finally {
+            rl.removeListener('SIGINT', onSigint);
+            turnInProgress = false;
+        }
+        // Status footer after each turn.
+        // tool_result messages also have role:'user' but content is an array —
+        // filter them out so we count actual user prompts, not tool rounds.
+        const userTurns = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
+        const lifetimeTokensAfter = session.usage.input_tokens + session.usage.output_tokens;
+        const turnTokens = Math.max(0, lifetimeTokensAfter - lifetimeTokensBefore);
+        // H4: do not write chalk status footer if Ink owns stdout — it corrupts
+        // the frame. The Ink path renders its own <StatusRow /> above <Footer>.
+        if (!shouldUseInk()) {
+            printStatusFooter({
+                sessionId: session.id,
+                sapAlias: selectedAlias,
+                skill: session.skill ?? '(none)',
+                turnCount: userTurns,
+                tokens: turnTokens,
+                cachedTokens: session.usage.cache_read_input_tokens,
+                elapsedMs: Date.now() - turnStart,
+            });
+        }
+        // Post-turn roll-forward (Step 7c.2 / 7c.5) — the skill from the turn that
+        // JUST finished becomes `last_skill` for the next turn's classifier context.
+        // `session.skill` itself is reassigned inside runTurn (agent/loop.ts) to the
+        // CURRENT turn's skill, so we must snapshot `previousSkill` BEFORE runTurn.
+        session.last_skill = previousSkill ?? null;
+        session.last_object = extractedObject ?? previousObject ?? null;
+    }
+}