@cspeach/cli 0.7.1 → 0.9.0

package/dist/ui/app.js

@@ -1,11 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import { Box, useInput } from 'ink';
 import crypto from 'node:crypto';
 import { Body } from './body.js';
 import { Footer } from './footer.js';
 import { ApprovalModal } from './approval-modal.js';
 import { CommandPalette } from './command-palette.js';
+import { FilePalette } from './file-palette.js';
+import { nextResolutionStep, applySlashPick, applyAtPick } from './line-resolution.js';
+import { TurnStatus } from './turn-status.js';
+import { turnStatusEmitter } from './turn-status-emitter.js';
+import { listWorkspaceFileChoices } from '../repl/at-picker.js';
 import { RichErrorBox } from './rich-error-box.js';
 import { SessionTimeline, toTimelineEntry } from './session-timeline.js';
 import { approvalEmitter } from './approval-emitter.js';
@@ -15,6 +20,7 @@ import { coachingPickerEmitter } from './coaching-picker-emitter.js';
 import { CoachingPicker } from './widgets/coaching-picker.js';
 import { askQuestionEmitter } from './ask-question-emitter.js';
 import { AskQuestionModal } from './widgets/ask-question-modal.js';
+import { enqueueSteering } from '../agent/steering-queue.js';
 /**
  * App — inline-mode Ink frame (Phase D6, 2026-05-17). After the
  * alt-screen detour, reverted to CC's architecture:
@@ -33,8 +39,13 @@ export function App({ chunkEmitter, onSubmit, onSlashTrigger, onHistoryTrigger,
     const [pendingApproval, setPendingApproval] = useState(null);
     const [coachingPending, setCoachingPending] = useState(null);
     const [askQuestionPending, setAskQuestionPending] = useState(null);
-    const [showPalette, setShowPalette] = useState(false);
-    const [paletteResult, setPaletteResult] = useState('');
+    // 2026-06-06 (Ink picker parity) — pre-dispatch line resolution. A
+    // submitted line flows through nextResolutionStep (line-resolution.ts);
+    // open-slash / open-at steps mount the matching palette seeded with the
+    // user's typed fragment; cancel restores the original line into the
+    // Footer via `prefill`. Replaces the old bare-`/`-only palette flow.
+    const [lineResolution, setLineResolution] = useState(null);
+    const [prefill, setPrefill] = useState({ text: '', nonce: 0 });
     const [errorStack, setErrorStack] = useState([]);
     const [showTimeline, setShowTimeline] = useState(false);
     const [footerValue, setFooterValue] = useState('');
@@ -72,20 +83,73 @@ export function App({ chunkEmitter, onSubmit, onSlashTrigger, onHistoryTrigger,
         errorEmitter.on('error', onError);
         return () => { errorEmitter.off('error', onError); };
     }, []);
+    // Run one step of the pre-dispatch pipeline and act on the outcome.
+    const handleStep = useCallback((step, original, files) => {
+        switch (step.kind) {
+            case 'submit':
+                onSubmit(step.line);
+                return;
+            case 'prefill':
+                chunkEmitter.emit('chunk', `\x1b[2m${step.hint}\x1b[22m\n`);
+                setPrefill((p) => ({ text: step.text, nonce: p.nonce + 1 }));
+                return;
+            case 'open-slash':
+                setLineResolution({ mode: 'slash', prefix: step.prefix, rest: step.rest, original, files });
+                return;
+            case 'open-at':
+                setLineResolution({ mode: 'at', prefix: step.prefix, line: step.line, original, files });
+                return;
+        }
+    }, [onSubmit, chunkEmitter]);
+    // Footer submissions enter here instead of going straight to the REPL
+    // handler — slash + @ tokens get resolved (palette if ambiguous) first.
+    const beginSubmit = useCallback((line) => {
+        // 2026-06-07 (B5 smoke): Enter while a turn is streaming used to slip
+        // through — the pipeline opened a palette OVER the live stream, and a
+        // pick would have dispatched a SECOND concurrent turn into the same
+        // session. Keep the typed text in the input and tell the user; proper
+        // CC-style input queueing is a follow-up (docs/backlog.md).
+        if (turnStatusEmitter.snapshot().active) {
+            // CC-style mid-turn steering (2026-06-08): the user typed a correction
+            // while the model works. Queue it — the turn loop injects it as a user
+            // message at the next round boundary — clear the box, and confirm it
+            // landed. (Was: bounce the input and tell them to wait.)
+            const t = line.trim();
+            if (t.length > 0) {
+                enqueueSteering(t);
+                chunkEmitter.emit('chunk', `\x1b[36m↳ queued ▸ ${t}\x1b[39m\n`);
+            }
+            setPrefill((p) => ({ text: '', nonce: p.nonce + 1 }));
+            return;
+        }
+        const files = listWorkspaceFileChoices();
+        handleStep(nextResolutionStep(line, files), line, files);
+    }, [handleStep, chunkEmitter]);
+    // Palette cancel: restore the user's original line so they can edit it.
+    const cancelResolution = useCallback(() => {
+        const lr = lineResolution;
+        setLineResolution(null);
+        if (lr && lr.original.trim().length > 0) {
+            setPrefill((p) => ({ text: lr.original, nonce: p.nonce + 1 }));
+        }
+    }, [lineResolution]);
     // `?` key opens the timeline when the footer is empty and no other overlay
     // is active.
     useInput((input, _key) => {
         if (input === '?' && footerValue === '')
             setShowTimeline(true);
-    }, { isActive: !showPalette && !showTimeline && !pendingApproval && !coachingPending });
+    }, { isActive: !lineResolution && !showTimeline && !pendingApproval && !coachingPending });
     // Ctrl+C handler — abort in-flight turn or exit at idle.
     useInput((input, key) => {
         if (key.ctrl && input === 'c')
             onInterrupt?.();
     }, { isActive: true });
     const clearApproval = () => setPendingApproval(null);
+    // Bare `/` + Enter — browse the full catalogue. Same palette as the
+    // typed-prefix flow, just unfiltered, with nothing to restore on cancel.
     const handleSlashTrigger = () => {
-        setShowPalette(true);
+        const files = listWorkspaceFileChoices();
+        setLineResolution({ mode: 'slash', prefix: '', rest: '', original: '', files });
         onSlashTrigger?.();
     };
     const handleHistoryTrigger = () => {
@@ -103,18 +167,23 @@ export function App({ chunkEmitter, onSubmit, onSlashTrigger, onHistoryTrigger,
                     } })), askQuestionPending && (_jsx(AskQuestionModal, { params: askQuestionPending, onResolve: (result) => {
                         askQuestionPending.resolve(result);
                         setAskQuestionPending(null);
-                    } })), _jsx(Footer, { onSubmit: onSubmit, onSlashTrigger: handleSlashTrigger, onHistoryTrigger: handleHistoryTrigger, paletteResult: paletteResult, onValueChange: setFooterValue, 
+                    } })), _jsx(TurnStatus, {}), _jsx(Footer, { onSubmit: beginSubmit, onSlashTrigger: handleSlashTrigger, onHistoryTrigger: handleHistoryTrigger, prefill: prefill, onValueChange: setFooterValue, 
                     // 2026-05-17 — disable Footer input while any modal owns
                     // input, so keystrokes don't double-fire (modal answer +
                     // spurious Footer submission with same text).
                     disabled: !!coachingPending
                         || !!askQuestionPending
                         || !!pendingApproval
-                        || showPalette
-                        || showTimeline }), showPalette && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(CommandPalette, { onSelect: (s) => {
-                            setPaletteResult(s);
-                            setShowPalette(false);
-                        }, onCancel: () => setShowPalette(false) }) })), errorStack.map((e) => (_jsx(Box, { children: _jsx(RichErrorBox, { code: e.code, message: e.body, hint: e.hint, severity: "error" }) }, e.id))), showTimeline && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(SessionTimeline, { entries: timelineEntries, onClose: () => setShowTimeline(false) }) })), pendingApproval && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(ApprovalModal, { change: pendingApproval.change, effectiveRisk: pendingApproval.effectiveRisk, transport: pendingApproval.transport, onApply: () => {
+                        || !!lineResolution
+                        || showTimeline }), lineResolution?.mode === 'slash' && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(CommandPalette, { initialQuery: lineResolution.prefix, onSelect: (name) => {
+                            const lr = lineResolution;
+                            setLineResolution(null);
+                            handleStep(applySlashPick(name, lr.rest, lr.files), lr.original, lr.files);
+                        }, onCancel: cancelResolution }) })), lineResolution?.mode === 'at' && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(FilePalette, { files: lineResolution.files, initialQuery: lineResolution.prefix, onSelect: (filename) => {
+                            const lr = lineResolution;
+                            setLineResolution(null);
+                            handleStep(applyAtPick(lr.line, filename, lr.files), lr.original, lr.files);
+                        }, onCancel: cancelResolution }) })), errorStack.map((e) => (_jsx(Box, { children: _jsx(RichErrorBox, { code: e.code, message: e.body, hint: e.hint, severity: "error" }) }, e.id))), showTimeline && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(SessionTimeline, { entries: timelineEntries, onClose: () => setShowTimeline(false) }) })), pendingApproval && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(ApprovalModal, { change: pendingApproval.change, effectiveRisk: pendingApproval.effectiveRisk, transport: pendingApproval.transport, onApply: () => {
                             pendingApproval.resolve({ approved: true });
                             clearApproval();
                         }, onSkip: () => {

package/dist/ui/body.js

@@ -3,6 +3,56 @@ import React, { useReducer, useEffect } from 'react';
 import { Text, Static } from 'ink';
 import { WIDGET_COMPONENTS } from './widgets/component-registry.js';
 import { WIDGET_CONTROL } from './widget-control.js';
+/**
+ * Frame interval for batching streaming chunks before dispatching to the
+ * reducer (W2.2 — 2026-05-18). Ink already throttles its stdout writes to
+ * 32 ms via `es-toolkit/compat throttle` at the renderer level — but the
+ * React **reducer** still runs once per chunk in our useReducer setup.
+ * For a long code-gen turn (5000+ chunks of 1-3 bytes each), the cumulative
+ * regex-split + string-concat cost in `bodyReducer` becomes the hotspot.
+ *
+ * Batching here gives one reducer call per ~16 ms regardless of chunk rate,
+ * preserving the perceived "real-time stream" feel (still 60Hz) while
+ * collapsing reducer work by 1-2 orders of magnitude on dense streams.
+ *
+ * `requestAnimationFrame` is unavailable in Node, so we use `setTimeout(16)` —
+ * same effective cadence, cross-platform safe. We re-arm the timer only when
+ * a chunk arrives and no flush is pending, so an idle stream pays nothing.
+ */
+export const RENDER_BATCH_MS = 16;
+export function createChunkBatcher(onFlush, intervalMs = RENDER_BATCH_MS) {
+    let buffered = '';
+    let timer = null;
+    const fire = () => {
+        timer = null;
+        if (buffered.length === 0)
+            return;
+        const out = buffered;
+        buffered = '';
+        onFlush(out);
+    };
+    return {
+        push(chunk) {
+            if (chunk.length === 0)
+                return;
+            buffered += chunk;
+            if (timer === null) {
+                timer = setTimeout(fire, intervalMs);
+            }
+        },
+        dispose() {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            if (buffered.length > 0) {
+                const out = buffered;
+                buffered = '';
+                onFlush(out);
+            }
+        },
+    };
+}
 // WIDGET_CONTROL is the longer sentinel (`\x00CSPEACH-WIDGET-V3\x00`).
 // RegExp escaping: `\x00` works in JS regex source directly.
 const WIDGET_RE = new RegExp(WIDGET_CONTROL.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
@@ -105,9 +155,18 @@ function renderNode(n) {
 export const Body = React.memo(function Body({ chunkEmitter }) {
     const [state, dispatch] = useReducer(bodyReducer, INITIAL_BODY_STATE);
     useEffect(() => {
-        const handler = (chunk) => dispatch({ chunk });
+        // W2.2 — chunk batching. createChunkBatcher buffers incoming chunks
+        // and dispatches at most once per RENDER_BATCH_MS window. Idle stream
+        // pays nothing; dense stream (e.g. 5000 chunks during code-gen) sees
+        // ~60 reducer calls instead of 5000. dispose() flushes pending text
+        // synchronously on unmount so end-of-stream output isn't dropped.
+        const batcher = createChunkBatcher((buffered) => dispatch({ chunk: buffered }));
+        const handler = (chunk) => batcher.push(chunk);
         chunkEmitter.on('chunk', handler);
-        return () => { chunkEmitter.off('chunk', handler); };
+        return () => {
+            chunkEmitter.off('chunk', handler);
+            batcher.dispose();
+        };
     }, [chunkEmitter]);
     // <Static> takes the nodes array; on each render it appends ONLY new
     // items since the last render. Already-rendered items are not

package/dist/ui/command-palette.js

@@ -2,15 +2,42 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useMemo } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
-import Fuse from 'fuse.js';
-import { SKILL_CATALOG } from '../skill-catalog.js';
-export function CommandPalette({ onSelect, onCancel }) {
-    const [query, setQuery] = useState('');
+import { ALL_SLASH_ENTRIES } from '../repl/slash-picker.js';
+const VISIBLE_ROWS = 8;
+// Longest command is /abap-transport-analysis (24) — fixed column keeps
+// every row single-line; the outer wrap="truncate-end" clips descriptions
+// at the terminal edge instead of wrapping into multi-line soup.
+const NAME_COL = 26;
+/**
+ * Deterministic CC-style ranking (2026-06-06 — replaced Fuse): prefix
+ * matches first, then substring matches, each group alphabetical. A
+ * query like `abap-` lists everything in order instead of fuzzy-score
+ * noise; `rada` still surfaces /abap-radar via the substring group.
+ */
+export function rankCommandMatches(query) {
+    const q = query.trim().toLowerCase().replace(/^\//, '');
+    if (q.length === 0)
+        return [...ALL_SLASH_ENTRIES];
+    const starts = [];
+    const contains = [];
+    for (const e of ALL_SLASH_ENTRIES) {
+        const bare = e.name.slice(1).toLowerCase();
+        if (bare.startsWith(q))
+            starts.push(e);
+        else if (bare.includes(q))
+            contains.push(e);
+    }
+    return [...starts, ...contains];
+}
+/**
+ * CC-style command menu (2026-06-06 rewrite): borderless single-line
+ * rows under the filter input, full result list navigable via a
+ * scrolling window — the cursor is never clamped to the first page.
+ */
+export function CommandPalette({ initialQuery, onSelect, onCancel }) {
+    const [query, setQuery] = useState(initialQuery ?? '');
     const [cursor, setCursor] = useState(0);
-    const fuse = useMemo(() => new Fuse(SKILL_CATALOG, { keys: ['name', 'description'], threshold: 0.4 }), []);
-    const results = useMemo(() => query
-        ? fuse.search(query).slice(0, 8).map((r) => r.item)
-        : SKILL_CATALOG.slice(0, 8), [query, fuse]);
+    const results = useMemo(() => rankCommandMatches(query), [query]);
     useEffect(() => { setCursor(0); }, [query]);
     useInput((_input, key) => {
         if (key.escape) {
@@ -26,9 +53,18 @@ export function CommandPalette({ onSelect, onCancel }) {
             return;
         }
         if (key.return && results[cursor]) {
-            onSelect(`/${results[cursor].name} `);
+            onSelect(results[cursor].name);
             return;
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, width: 60, children: [_jsx(Text, { bold: true, color: "cyan", children: "Command palette" }), _jsx(TextInput, { value: query, onChange: setQuery, placeholder: "Type to filter..." }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: results.map((skill, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: i === cursor ? 'cyan' : 'white', bold: i === cursor, children: [i === cursor ? '\u25B8' : ' ', " /", skill.name.padEnd(20)] }), _jsx(Text, { dimColor: true, children: skill.description })] }, skill.name))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: insert  Esc: cancel" }) })] }));
+    // Scrolling window: keep the cursor ~3 rows from the top while there is
+    // more below, like CC's menu.
+    const windowStart = Math.max(0, Math.min(cursor - 3, results.length - VISIBLE_ROWS));
+    const visible = results.slice(windowStart, windowStart + VISIBLE_ROWS);
+    const below = Math.max(0, results.length - (windowStart + VISIBLE_ROWS));
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "/ " }), _jsx(TextInput, { value: query, onChange: setQuery, placeholder: "type to filter commands" })] }), results.length === 0 && (_jsx(Text, { dimColor: true, children: "  no matching command \u2014 edit the filter or Esc to cancel" })), windowStart > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", windowStart, " more"] }), visible.map((e, i) => {
+                const idx = windowStart + i;
+                const sel = idx === cursor;
+                return (_jsxs(Text, { wrap: "truncate-end", children: [_jsxs(Text, { color: sel ? 'cyan' : undefined, bold: sel, children: [sel ? '▸ ' : '  ', e.name.padEnd(NAME_COL)] }), _jsx(Text, { dimColor: true, children: e.description })] }, e.name));
+            }), below > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2193 ", below, " more"] }), _jsx(Text, { dimColor: true, children: "  \u2191\u2193 navigate \u00B7 Enter select \u00B7 Esc cancel" })] }));
 }

package/dist/ui/file-palette.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useMemo } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { filterFileChoices } from '../repl/at-picker.js';
+const VISIBLE_ROWS = 8;
+/**
+ * CC-style workspace-file menu (2026-06-06, matches CommandPalette):
+ * borderless single-line rows, substring filtering (filenames are
+ * structured ids — fuzzy would surface lookalike envelope versions),
+ * full result list navigable via a scrolling window.
+ */
+export function FilePalette({ files, initialQuery, onSelect, onCancel }) {
+    const [query, setQuery] = useState(initialQuery ?? '');
+    const [cursor, setCursor] = useState(0);
+    const results = useMemo(() => filterFileChoices(query, files), [query, files]);
+    useEffect(() => { setCursor(0); }, [query]);
+    useInput((_input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.upArrow) {
+            setCursor((c) => Math.max(0, c - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor((c) => Math.min(results.length - 1, c + 1));
+            return;
+        }
+        if (key.return && results[cursor]) {
+            onSelect(results[cursor].filename);
+            return;
+        }
+    });
+    const windowStart = Math.max(0, Math.min(cursor - 3, results.length - VISIBLE_ROWS));
+    const visible = results.slice(windowStart, windowStart + VISIBLE_ROWS);
+    const below = Math.max(0, results.length - (windowStart + VISIBLE_ROWS));
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "@ " }), _jsx(TextInput, { value: query, onChange: setQuery, placeholder: "type to filter workspace files" })] }), results.length === 0 && (_jsx(Text, { dimColor: true, children: "  no matching file \u2014 edit the filter or Esc to cancel" })), windowStart > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", windowStart, " more"] }), visible.map((f, i) => {
+                const idx = windowStart + i;
+                const sel = idx === cursor;
+                return (_jsx(Text, { wrap: "truncate-end", children: _jsxs(Text, { color: sel ? 'cyan' : undefined, bold: sel, children: [sel ? '▸ ' : '  ', f.filename] }) }, f.filename));
+            }), below > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2193 ", below, " more"] }), _jsx(Text, { dimColor: true, children: "  \u2191\u2193 navigate \u00B7 Enter select \u00B7 Esc cancel" })] }));
+}

package/dist/ui/footer.js

@@ -24,7 +24,7 @@ function appendHistory(line, history) {
     history.push(line);
 }
 const PEACH = '#FFCBA4';
-export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, paletteResult, disabled }) {
+export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled }) {
     const [value, setValue] = useState('');
     const [history] = useState(loadHistory);
     const [histIdx, setHistIdx] = useState(-1);
@@ -34,11 +34,14 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
     const fuse = React.useMemo(() => new Fuse(history, { threshold: 0.4 }), [history]);
     // Mirror state into parent when it cares (e.g. App's ? key-binding gate).
     useEffect(() => { onValueChange?.(value); }, [value, onValueChange]);
-    // If the parent pushes a palette result, pre-fill our input.
+    // If the parent pushes a prefill (palette pick, palette cancel restore,
+    // empty-body guard), pre-fill our input. Keyed on the nonce so identical
+    // text can re-fire.
     useEffect(() => {
-        if (paletteResult && paletteResult.length > 0)
-            setValue(paletteResult);
-    }, [paletteResult]);
+        if (prefill && prefill.text.length > 0)
+            setValue(prefill.text);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [prefill?.nonce]);
     useEffect(() => {
         if (fuzzyMode) {
             setFuzzyResults(fuse.search(fuzzyQuery).slice(0, 8).map((r) => r.item));

package/dist/ui/line-resolution.js

@@ -0,0 +1,81 @@
+// cspeach-cli/src/ui/line-resolution.ts
+//
+// Pure pre-dispatch resolution pipeline for the Ink input path
+// (2026-06-06 — Ink parity with the classic REPL's slash/at pickers,
+// repl.tsx ~1535-1640). Given a submitted line, decide ONE of:
+//
+//   submit      — line is fully resolved; hand it to the REPL handler
+//   open-slash  — line starts with a non-exact slash command; the App
+//                 mounts the CommandPalette seeded with the typed prefix
+//   open-at     — line ends with a partial/unresolved @-token; the App
+//                 mounts the FilePalette seeded with the typed prefix
+//   prefill     — skill command with no body; put `<cmd> ` back in the
+//                 input instead of dispatching an empty prompt the API
+//                 would reject (mirrors classic repl.tsx ~1626)
+//
+// Same auto-shortcuts as the classic pickers: a prefix that narrows to
+// exactly ONE command / file resolves silently — no palette, no extra
+// keystroke. The App calls nextResolutionStep again after every palette
+// pick, so a line flows slash → at → empty-body guard → submit no
+// matter where it entered the pipeline.
+import { isExactSlashMatch, filterSlashEntries } from '../repl/slash-picker.js';
+import { pendingAtTokenPrefix, filterFileChoices } from '../repl/at-picker.js';
+import { SKILL_CATALOG } from '../skill-catalog.js';
+export function nextResolutionStep(line, files) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('/') && !isExactSlashMatch(trimmed)) {
+        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);
+        const seeded = filterSlashEntries(prefix);
+        if (seeded.length === 1) {
+            // Unique match — resolve silently and continue down the pipeline.
+            return nextResolutionStep(`${seeded[0].name}${rest}`, files);
+        }
+        return { kind: 'open-slash', prefix, rest };
+    }
+    const filenames = files.map((f) => f.filename);
+    const atPrefix = pendingAtTokenPrefix(trimmed, filenames);
+    if (atPrefix !== null && files.length > 0) {
+        const seeded = filterFileChoices(atPrefix, files);
+        if (seeded.length === 1) {
+            return emptyBodyGuard(trimmed.replace(/@\S*$/, `@${seeded[0].filename}`));
+        }
+        return { kind: 'open-at', prefix: atPrefix, line: trimmed };
+    }
+    // Empty workspace: nothing to pick — let the downstream @-resolution
+    // produce its normal "no file matching" message.
+    return emptyBodyGuard(trimmed);
+}
+/** Substitute the picked command head into the pending line and continue. */
+export function applySlashPick(pickedName, rest, files) {
+    const name = pickedName.startsWith('/') ? pickedName : `/${pickedName}`;
+    return nextResolutionStep(`${name}${rest}`, files);
+}
+/** Substitute the picked filename into the rightmost @-token and continue. */
+export function applyAtPick(line, pickedFilename, files) {
+    return nextResolutionStep(line.replace(/@\S*$/, `@${pickedFilename}`), files);
+}
+/**
+ * A SKILL route with an empty body would dispatch an empty prompt the
+ * LLM API rejects — prefill `<cmd> ` instead (classic repl.tsx ~1626).
+ * Builtins (/help, /exit, /transport …) legitimately take no body and
+ * pass straight through.
+ */
+function emptyBodyGuard(line) {
+    if (line.startsWith('/')) {
+        const splitIdx = line.search(/\s/);
+        const head = splitIdx === -1 ? line : line.slice(0, splitIdx);
+        const body = splitIdx === -1 ? '' : line.slice(splitIdx).trim();
+        const isSkill = SKILL_CATALOG.some((s) => `/${s.name}` === head.toLowerCase());
+        if (isSkill && body.length === 0) {
+            return {
+                kind: 'prefill',
+                text: `${head} `,
+                hint: `↪ ${head} — type your prompt and press Enter`,
+            };
+        }
+    }
+    return { kind: 'submit', line };
+}

package/dist/ui/turn-status-emitter.js

@@ -0,0 +1,52 @@
+// cspeach-cli/src/ui/turn-status-emitter.ts
+//
+// Turn-lifecycle channel for the persistent status row (2026-06-07 —
+// the CC-style "always alive while working" indicator, B5 smoke
+// feedback round 3: fresh-line heartbeats were not enough).
+//
+// Same singleton-emitter pattern as error-emitter / approval-emitter:
+// the REPL marks turn start/stop around runTurn (try/finally so a
+// thrown turn can never leave the row stuck), loop.ts narrates the
+// current activity, and <TurnStatus /> renders it in the dynamic Ink
+// frame. In classic mode App is never mounted, the emitter has no
+// listeners, and every call is a no-op.
+import { EventEmitter } from 'node:events';
+class TurnStatusEmitter extends EventEmitter {
+    state = { active: false, paused: false, label: '', startedAt: 0 };
+    start(label = 'thinking') {
+        this.state = { active: true, paused: false, label, startedAt: Date.now() };
+        this.emit('change', this.state);
+    }
+    /** Update the activity label; ignored when no turn is active. Clears pause —
+     *  a real activity means the model is working again. */
+    activity(label) {
+        if (!this.state.active)
+            return;
+        this.state = { ...this.state, label, paused: false };
+        this.emit('change', this.state);
+    }
+    /** Blocked on user input — stop ticking and hide the row until resume(). */
+    pause() {
+        if (!this.state.active || this.state.paused)
+            return;
+        this.state = { ...this.state, paused: true };
+        this.emit('change', this.state);
+    }
+    /** User answered — the model is working again; bring the row back. */
+    resume() {
+        if (!this.state.active || !this.state.paused)
+            return;
+        this.state = { ...this.state, paused: false };
+        this.emit('change', this.state);
+    }
+    stop() {
+        if (!this.state.active)
+            return;
+        this.state = { active: false, paused: false, label: '', startedAt: 0 };
+        this.emit('change', this.state);
+    }
+    snapshot() {
+        return this.state;
+    }
+}
+export const turnStatusEmitter = new TurnStatusEmitter();

package/dist/ui/turn-status.js

@@ -0,0 +1,59 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { turnStatusEmitter } from './turn-status-emitter.js';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const TICK_MS = 250;
+const PEACH = '#FFCBA4';
+function fmtElapsed(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    return `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+/**
+ * Persistent turn-status row (2026-06-07) — lives in the DYNAMIC Ink
+ * frame just above the Footer, so it repaints with the frame and
+ * vanishes the instant the turn ends. While a turn is in flight:
+ *
+ *   ⠹ sap_create_object · 34s · ctrl+c to interrupt
+ *
+ * The label follows the loop's narration (thinking / tool name /
+ * writing response / save check). Its presence answers "is it still
+ * working?"; its absence answers "is it done?" — the ambiguity that
+ * burned the B5 smoke three times.
+ *
+ * Pure Ink — no raw stdout writes, no cursor escape codes (the phantom
+ * cursor #25 class of bug came from a raw-stdout spinner; this
+ * component cannot reproduce it). Guard: ink-cursor-invariant test.
+ */
+export function TurnStatus() {
+    const [state, setState] = useState(turnStatusEmitter.snapshot());
+    const [frame, setFrame] = useState(0);
+    const [now, setNow] = useState(Date.now());
+    useEffect(() => {
+        const onChange = (s) => setState({ ...s });
+        turnStatusEmitter.on('change', onChange);
+        // Re-sync from the snapshot AFTER subscribing — an event fired between
+        // mount and this effect (e.g. a turn starting while App is still
+        // mounting) would otherwise be missed and the row stays blank.
+        setState({ ...turnStatusEmitter.snapshot() });
+        return () => { turnStatusEmitter.off('change', onChange); };
+    }, []);
+    useEffect(() => {
+        // Don't tick while paused (blocked on user input) — a live tick here
+        // repaints the dynamic frame every 250ms and overdraws an inquirer
+        // approval picker / churns the Ink ask_question modal (stacked borders,
+        // lost keypress). The row resumes the instant the user answers.
+        if (!state.active || state.paused)
+            return;
+        const interval = setInterval(() => {
+            setFrame((f) => (f + 1) % FRAMES.length);
+            setNow(Date.now());
+        }, TICK_MS);
+        return () => clearInterval(interval);
+    }, [state.active, state.paused]);
+    if (!state.active || state.paused)
+        return null;
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: PEACH, children: [FRAMES[frame], " "] }), _jsx(Text, { children: state.label }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", fmtElapsed(now - state.startedAt), " \u00B7 ctrl+c to interrupt"] })] }));
+}

package/dist/ui/widgets/ask-question-modal.js

@@ -15,11 +15,36 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * learned the hard way that absolute overlays paint over Body and
  * can't be navigated cleanly).
  */
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
 const PEACH = '#FFCBA4';
+/**
+ * Reclaim raw-mode stdin when an Ink modal mounts (2026-06-08).
+ *
+ * The approval plan-gate uses `@inquirer/prompts`, which toggles the
+ * terminal's raw mode (and pauses stdin) out from under Ink while it runs.
+ * When it releases, Ink's INTERNAL bookkeeping still thinks raw mode is on,
+ * so it does not re-assert it — and a modal mounted afterwards (this one)
+ * receives no keypresses: arrow keys and Enter are dead, the user cannot
+ * answer the question. Re-syncing the OS state to what Ink expects on mount
+ * fixes it. Direct `process.stdin` calls (not Ink's ref-counted setRawMode)
+ * because the whole problem is that Ink's count is stale.
+ */
+function useReclaimRawStdin() {
+    useEffect(() => {
+        const stdin = process.stdin;
+        if (stdin.isTTY && typeof stdin.setRawMode === 'function') {
+            try {
+                stdin.setRawMode(true);
+            }
+            catch { /* not a TTY — ignore */ }
+            stdin.resume();
+        }
+    }, []);
+}
 export function AskQuestionModal({ params, onResolve }) {
+    useReclaimRawStdin();
     if (params.kind === 'text' || params.choices.length === 0) {
         return _jsx(TextInputForm, { params: params, onResolve: onResolve });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",
@@ -40,6 +40,7 @@
     "adt:smoke": "tsx scripts/adt-smoke.ts",
     "smoke:all": "pnpm zcspeach:smoke && pnpm adt:smoke",
     "zcspeach:smoke": "tsx scripts/zcspeach-smoke.ts",
+    "bench:models": "tsx scripts/bench-models.ts",
     "prepare": "husky"
   },
   "engines": {
@@ -81,6 +82,9 @@
     "vitest": "^2.1.0"
   },
   "pnpm": {
-    "onlyBuiltDependencies": ["keytar", "esbuild"]
+    "onlyBuiltDependencies": [
+      "keytar",
+      "esbuild"
+    ]
   }
 }