@cspeach/cli 0.8.0 → 1.0.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 } 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,27 @@ 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);
+                            // Insert the picked filename into the @-token and KEEP the input —
+                            // do NOT auto-submit. This lets the user keep typing after picking
+                            // (e.g. add `--scope ZMM_VENDOR_CHECK` after `--from @<file>`).
+                            const resolved = lr.line.replace(/@\S*$/, `@${filename}`);
+                            setPrefill((p) => ({ text: `${resolved} `, nonce: p.nonce + 1 }));
+                        }, 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,7 @@ 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';
+import { formatNoticeLine } from '../renderer/notices.js';
 /**
  * Frame interval for batching streaming chunks before dispatching to the
  * reducer (W2.2 — 2026-05-18). Ink already throttles its stdout writes to
@@ -162,9 +163,21 @@ export const Body = React.memo(function Body({ chunkEmitter }) {
         // synchronously on unmount so end-of-stream output isn't dropped.
         const batcher = createChunkBatcher((buffered) => dispatch({ chunk: buffered }));
         const handler = (chunk) => batcher.push(chunk);
+        // B2 fix (2026-06-12) — consume the 'warn'/'info' notice channel.
+        // Tool handlers (transport-resolution Rule 9 notices, write-tool
+        // snapshot lines) emit these levels on the same emitter; before this
+        // they were silent no-ops in the live Ink REPL. Notices are formatted
+        // to a single line and pushed through the SAME batcher so their order
+        // relative to surrounding chunk text is preserved.
+        const warnHandler = (msg) => batcher.push(formatNoticeLine('warn', msg));
+        const infoHandler = (msg) => batcher.push(formatNoticeLine('info', msg));
         chunkEmitter.on('chunk', handler);
+        chunkEmitter.on('warn', warnHandler);
+        chunkEmitter.on('info', infoHandler);
         return () => {
             chunkEmitter.off('chunk', handler);
+            chunkEmitter.off('warn', warnHandler);
+            chunkEmitter.off('info', infoHandler);
             batcher.dispose();
         };
     }, [chunkEmitter]);

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

@@ -1,15 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useState, useEffect, useCallback } from 'react';
 import { Box, Text, useInput } from 'ink';
-import TextInput from 'ink-text-input';
+// D29 paste fix (2026-06-12): vendored paste-safe replacement for
+// ink-text-input — multi-chunk pastes were losing every chunk but the
+// last (stale-prop closure in the upstream component). See text-input.tsx.
+import TextInput from './text-input.js';
 import Fuse from 'fuse.js';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-const HISTORY_FILE = path.join(os.homedir(), '.cspeach', 'history');
+// Resolved lazily (not at module load) so it honours the HOME/USERPROFILE
+// active at render time — lets tests point it at a temp dir.
+function historyFile() {
+    return path.join(os.homedir(), '.cspeach', 'history');
+}
 function loadHistory() {
     try {
-        return fs.readFileSync(HISTORY_FILE, 'utf8').split('\n').filter(Boolean);
+        return fs.readFileSync(historyFile(), 'utf8').split('\n').filter(Boolean);
     }
     catch {
         return [];
@@ -19,12 +26,13 @@ function appendHistory(line, history) {
     // Skip consecutive duplicates (matches bash HISTCONTROL=ignoredups).
     if (history[history.length - 1] === line)
         return;
-    fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
-    fs.appendFileSync(HISTORY_FILE, line + '\n');
+    const file = historyFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, line + '\n');
     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 +42,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));
@@ -79,7 +90,13 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             setValue(next === -1 ? '' : history[history.length - 1 - next] ?? '');
             return;
         }
-    });
+        // 2026-06-16 — go dormant while a modal (ask_question / coaching picker)
+        // owns input. Without this, arrow-key navigation INSIDE the modal also
+        // hits this handler (Ink delivers every keystroke to every active
+        // useInput), recalling a history line into the hidden Footer — so the
+        // last command "comes back" in the input once the modal closes. Mirrors
+        // why the TextInput is swapped for a placeholder when disabled.
+    }, { isActive: !disabled });
     const handleSubmit = useCallback((line) => {
         if (!line.trim())
             return;

package/dist/ui/line-resolution.js

@@ -0,0 +1,92 @@
+// 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 } from '../repl/at-picker.js';
+import { SKILL_CATALOG, SKILL_ALIASES } 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) {
+        // Always open the picker when the line ends in an unresolved @-token —
+        // even when it narrows to a single file. The old single-match shortcut
+        // silently auto-resolved AND auto-submitted, so the user never saw which
+        // file was attached and couldn't keep typing (e.g. add `--scope`). Showing
+        // the palette + inserting-on-pick (App handles that) is the correct flow.
+        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();
+        // Retired-but-redirected name with no body: prefill the NEW name so the
+        // user both learns the rename and doesn't dispatch an empty prompt.
+        const aliasTarget = SKILL_ALIASES[head.toLowerCase().slice(1)];
+        if (aliasTarget !== undefined && body.length === 0) {
+            return {
+                kind: 'prefill',
+                text: `/${aliasTarget} `,
+                hint: `↪ ${head.toLowerCase()} is now /${aliasTarget} — type your prompt and press Enter`,
+            };
+        }
+        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/session-timeline.js

@@ -6,6 +6,7 @@ const MUTATING_TOOLS = new Set([
     'sap_set_source', 'sap_update_method', 'sap_delete_object', 'sap_activate',
     'sap_create_object', 'sap_transport_release', 'sap_message_maintain',
     'sap_number_range_intervals', 'sap_service_binding_publish',
+    'sap_service_binding_unpublish',
 ]);
 export function toTimelineEntry(call) {
     // args shape depends on the tool; extract defensively.

package/dist/ui/text-input.js

@@ -0,0 +1,150 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * PasteSafeTextInput — drop-in replacement for `ink-text-input` (D29,
+ * "chewed words" during seed-session paste; 2026-06-12).
+ *
+ * ROOT CAUSE of the chewing, verified by repro test: Ink's App drains ALL
+ * pending stdin chunks in one synchronous loop (components/App.js
+ * `handleReadable`: `while ((chunk = stdin.read()) !== null) emit('input')`),
+ * and a large terminal paste arrives as MULTIPLE chunks. ink-text-input
+ * computes `nextValue = value.slice(0, cursor) + input + …` from the
+ * `value` PROP of the last committed render — a stale closure for every
+ * chunk after the first in the same tick. With chunks A then B, B's
+ * handler still sees the pre-A value, so A is silently dropped:
+ * `stdin.write('hello '); stdin.write('world')` → value `"world"`.
+ *
+ * FIX: mirror value + cursor in refs that are updated SYNCHRONOUSLY inside
+ * the input handler, so consecutive same-tick chunks compound. The refs
+ * re-sync from props on commit, so external value pushes (submit-clear,
+ * palette prefill) still win between keystrokes. This also fixes the
+ * sibling hazard: an Enter that lands in the same drain as the paste tail
+ * now submits the COMPLETE value instead of the stale prop.
+ *
+ * Rendering, cursor drawing, placeholder, and mask behaviour are vendored
+ * verbatim from ink-text-input v6 (MIT, © Vadim Demedes) minus
+ * `highlightPastedText` (Footer never used it).
+ */
+import { useState, useEffect, useRef } from 'react';
+import { Text, useInput } from 'ink';
+import chalk from 'chalk';
+export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, }) {
+    const [cursorOffset, setCursorOffset] = useState((originalValue || '').length);
+    // The paste-safety core: synchronous mirrors of value + cursor. The
+    // input handler reads/writes THESE, never the (possibly stale) props.
+    const valueRef = useRef(originalValue);
+    const cursorRef = useRef(cursorOffset);
+    // Values we've sent through onChange whose prop echo hasn't been
+    // observed yet. Needed because passive effects flush LATE: with N
+    // same-tick chunks, the echo effect for chunk k can run AFTER the
+    // handler for chunk k+1, and blindly assigning `valueRef.current =
+    // originalValue` would rewind the mirror to a stale value (observed in
+    // the repro as words landing out of order). An echo — even a stale
+    // one — must never overwrite the mirror; only EXTERNAL pushes may.
+    const pendingEchoes = useRef([]);
+    // Re-sync the mirrors on EXTERNAL value pushes only (parent setValue('')
+    // after submit, palette prefill). Echoes of our own onChange — current
+    // or stale — are recognised via pendingEchoes and skipped: the mirror
+    // is already at or ahead of them.
+    useEffect(() => {
+        const echoIdx = pendingEchoes.current.indexOf(originalValue);
+        if (echoIdx !== -1) {
+            pendingEchoes.current.splice(0, echoIdx + 1);
+            return;
+        }
+        pendingEchoes.current = [];
+        valueRef.current = originalValue;
+        if (cursorRef.current > originalValue.length) {
+            cursorRef.current = originalValue.length;
+            setCursorOffset(originalValue.length);
+        }
+    }, [originalValue]);
+    // Clamp rendered cursor when the value shrinks under it (vendored
+    // semantic from ink-text-input's first effect).
+    useEffect(() => {
+        if (!focus || !showCursor)
+            return;
+        setCursorOffset((previous) => previous > originalValue.length ? originalValue.length : previous);
+    }, [originalValue, focus, showCursor]);
+    const value = mask ? mask.repeat(originalValue.length) : originalValue;
+    let renderedValue = value;
+    let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
+    // Fake cursor — vendored rendering from ink-text-input v6.
+    if (showCursor && focus) {
+        renderedPlaceholder =
+            placeholder.length > 0
+                ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1))
+                : chalk.inverse(' ');
+        renderedValue = value.length > 0 ? '' : chalk.inverse(' ');
+        let i = 0;
+        for (const char of value) {
+            renderedValue += i === cursorOffset ? chalk.inverse(char) : char;
+            i++;
+        }
+        if (value.length > 0 && cursorOffset === value.length) {
+            renderedValue += chalk.inverse(' ');
+        }
+    }
+    useInput((input, key) => {
+        if (key.upArrow ||
+            key.downArrow ||
+            (key.ctrl && input === 'c') ||
+            key.tab ||
+            (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            // valueRef (not the prop) — so an Enter in the same stdin drain as
+            // the paste tail submits the complete line.
+            if (onSubmit)
+                onSubmit(valueRef.current);
+            return;
+        }
+        const currentValue = valueRef.current;
+        let nextCursorOffset = cursorRef.current;
+        let nextValue = currentValue;
+        if (key.leftArrow) {
+            if (showCursor)
+                nextCursorOffset--;
+        }
+        else if (key.rightArrow) {
+            if (showCursor)
+                nextCursorOffset++;
+        }
+        else if (key.backspace || key.delete) {
+            if (cursorRef.current > 0) {
+                nextValue =
+                    currentValue.slice(0, cursorRef.current - 1) +
+                        currentValue.slice(cursorRef.current, currentValue.length);
+                nextCursorOffset--;
+            }
+        }
+        else {
+            nextValue =
+                currentValue.slice(0, cursorRef.current) +
+                    input +
+                    currentValue.slice(cursorRef.current, currentValue.length);
+            nextCursorOffset += input.length;
+        }
+        if (nextCursorOffset < 0)
+            nextCursorOffset = 0;
+        if (nextCursorOffset > nextValue.length)
+            nextCursorOffset = nextValue.length;
+        // Synchronous mirror update FIRST — the next same-tick chunk builds
+        // on this, not on the stale render.
+        valueRef.current = nextValue;
+        cursorRef.current = nextCursorOffset;
+        setCursorOffset(nextCursorOffset);
+        if (nextValue !== currentValue) {
+            // Register the outgoing value so its (possibly late) prop echo is
+            // recognised and never rewinds the mirror.
+            pendingEchoes.current.push(nextValue);
+            onChange(nextValue);
+        }
+    }, { isActive: focus });
+    return (_jsx(Text, { children: placeholder
+            ? value.length > 0
+                ? renderedValue
+                : renderedPlaceholder
+            : renderedValue }));
+}
+export default PasteSafeTextInput;