@cspeach/cli 0.8.0 → 0.9.0

package/dist/repl.js

@@ -37,6 +37,7 @@ 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';
+import { isPlanResumeCommand } from './commands/plan-resume.js';
 /**
  * Pre-fill the readline buffer with `text`, cursor at end, and trigger
  * a redraw. Bypasses rl.write() — which simulates per-character
@@ -640,13 +641,20 @@ export async function runRepl(opts) {
                 chunkEmitter.emit('chunk', chalk.dim(`\n↪ Rerouting "${preview}" → /${rr.skill}\n`));
                 if (rr.warning)
                     chunkEmitter.emit('chunk', chalk.dim(`  (${rr.warning})\n`));
-                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,
-                });
+                const { turnStatusEmitter: rerouteStatus } = await import('./ui/turn-status-emitter.js');
+                rerouteStatus.start(`/${rr.skill}`);
+                try {
+                    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,
+                    });
+                }
+                finally {
+                    rerouteStatus.stop();
+                }
                 return;
             }
             // /new — clear any "awaiting skill answer" state so the next prompt
@@ -673,7 +681,9 @@ export async function runRepl(opts) {
             //   - `@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;
+            // `let`, not `const` — the B3 plan-resume interception below rewrites
+            // the prompt with the prepared bounded phase context before runTurn.
+            let prompt = parsed.prompt;
             const extractedObject = parsed.object ?? null;
             const previousSkill = session.skill;
             const previousObject = session.last_object ?? null;
@@ -765,7 +775,7 @@ export async function runRepl(opts) {
             // 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') &&
+            if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate' || skill === 'abap-plan') &&
                 /(^|\s)--status(\s|$)/.test(prompt)) {
                 try {
                     const files = prompt
@@ -785,6 +795,42 @@ export async function runRepl(opts) {
                 session.last_object = extractedObject ?? previousObject ?? null;
                 return;
             }
+            // B3 (2026-06-06) — `/abap-plan --resume @plan-file`. Token-free
+            // pre-work (load envelope, pick next eligible phase, print the
+            // tracker board, inline the phase's rule files) happens in
+            // preparePlanResume; terminal states (plan complete / all blocked)
+            // print and end the turn without any model call. When a phase IS
+            // eligible, the prepared bounded prompt replaces the user prompt
+            // and falls through to runTurn below — with suppressSaveHook so
+            // the new-envelope save hook stays quiet; finishPlanResume then
+            // persists the version-N+1 REVISION after the turn.
+            let planResume = null;
+            let planResumeMsgStart = 0;
+            if (skill === 'abap-plan' && /(^|\s)--resume(\s|$)/.test(prompt)) {
+                try {
+                    const { preparePlanResume } = await import('./commands/plan-resume.js');
+                    planResume = await preparePlanResume({
+                        body: prompt,
+                        cwd: process.cwd(),
+                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                    });
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[--resume] ${err.message}\n`));
+                }
+                if (!planResume) {
+                    session.last_skill = previousSkill ?? null;
+                    session.last_object = extractedObject ?? previousObject ?? null;
+                    return;
+                }
+                planResumeMsgStart = session.messages.length;
+                prompt = planResume.llmPrompt;
+            }
+            // 2026-06-08 — manifest-on-interrupt. Set true once the mid-turn
+            // onPlanManifest hook has persisted the revision, so the post-turn
+            // finishPlanResume below doesn't write it a second time.
+            let planSavedEarly = false;
+            const planResumeForHook = planResume;
             // Phase A** wiring fix (2026-05-16) — snapshot pre-turn counters so
             // pushPostTurnStatus can compute per-turn deltas. The classic-mode
             // turn loop has its own equivalent below; both paths now call the
@@ -798,6 +844,11 @@ export async function runRepl(opts) {
             // the signal we thread into runTurn.
             currentTurnAbort = new AbortController();
             interruptCount = 0;
+            // 2026-06-07 — persistent status row lifecycle. Started here (not in
+            // loop.ts) so the try/finally GUARANTEES the row clears even when the
+            // turn throws; loop.ts only narrates activity changes in between.
+            const { turnStatusEmitter } = await import('./ui/turn-status-emitter.js');
+            turnStatusEmitter.start(`/${skill}`);
             try {
                 await runTurn({
                     provider,
@@ -806,6 +857,27 @@ export async function runRepl(opts) {
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     chunkEmitter,
                     signal: currentTurnAbort.signal,
+                    suppressSaveHook: planResume !== null,
+                    // Persist the plan revision the instant its manifest is finalised
+                    // (before the continuation modal) so a Ctrl+C can't lose the phase.
+                    onPlanManifest: planResumeForHook
+                        ? async (assistantText) => {
+                            try {
+                                const { finishPlanResume } = await import('./commands/plan-resume.js');
+                                await finishPlanResume({
+                                    prepared: planResumeForHook,
+                                    messages: session.messages,
+                                    messagesStart: planResumeMsgStart,
+                                    log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                                    textOverride: assistantText,
+                                });
+                                planSavedEarly = true;
+                            }
+                            catch (err) {
+                                chunkEmitter.emit('chunk', chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
+                            }
+                        }
+                        : undefined,
                 });
             }
             catch (err) {
@@ -817,8 +889,31 @@ export async function runRepl(opts) {
                 });
             }
             finally {
+                turnStatusEmitter.stop();
                 currentTurnAbort = null;
             }
+            // B3 — persist the plan revision from the resume turn's manifest
+            // block (runs even after a turn error: partial assistant content is
+            // already in session.messages, and a phase may have written real SAP
+            // objects whose status must not be lost). FALLBACK path: skipped when
+            // the mid-turn onPlanManifest hook already saved it (manifest-on-
+            // interrupt, 2026-06-08). Still runs when no manifest was streamed —
+            // e.g. the turn errored before emitting one — so behaviour is unchanged
+            // for the no-manifest case.
+            if (planResume && !planSavedEarly) {
+                try {
+                    const { finishPlanResume } = await import('./commands/plan-resume.js');
+                    await finishPlanResume({
+                        prepared: planResume,
+                        messages: session.messages,
+                        messagesStart: planResumeMsgStart,
+                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                    });
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
+                }
+            }
             pushPostTurnStatus({ session, selectedAlias, snapshot: turnSnapshot, chunkEmitter });
             session.last_skill = previousSkill ?? null;
             session.last_object = extractedObject ?? previousObject ?? null;
@@ -830,7 +925,18 @@ export async function runRepl(opts) {
             const dispatched = pendingDispatchAccessor.get();
             if (dispatched) {
                 pendingDispatchAccessor.set(null);
-                chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${dispatched}\n`));
+                // Auto-fire next phase: a plan resume rebuilds its bounded prompt from
+                // the envelope, so clear the finished phase's transcript first — the
+                // next phase then costs exactly what a manual fresh resume costs.
+                // (The phase is already saved via manifest-on-interrupt, so nothing is
+                // lost; prior prose is mirrored to ~/.cspeach/streams/.)
+                if (isPlanResumeCommand(dispatched)) {
+                    session.messages = [];
+                    chunkEmitter.emit('chunk', chalk.dim('↪ Auto-running next phase in fresh context\n'));
+                }
+                else {
+                    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.
@@ -1164,7 +1270,13 @@ export async function runRepl(opts) {
         const dispatchedCmd = pendingDispatchAccessor.get();
         if (dispatchedCmd) {
             pendingDispatchAccessor.set(null);
-            console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
+            if (isPlanResumeCommand(dispatchedCmd)) {
+                session.messages = [];
+                console.log(chalk.dim('↪ Auto-running next phase in fresh context'));
+            }
+            else {
+                console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
+            }
             line = dispatchedCmd;
         }
         else {
@@ -1513,7 +1625,9 @@ export async function runRepl(opts) {
         //   - `@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;
+        // `let`, not `const` — the B3 plan-resume interception below rewrites
+        // the prompt with the prepared bounded phase context before runTurn.
+        let 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
@@ -1601,7 +1715,7 @@ export async function runRepl(opts) {
         // /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') &&
+        if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate' || skill === 'abap-plan') &&
             /(^|\s)--status(\s|$)/.test(prompt)) {
             try {
                 const files = prompt
@@ -1621,6 +1735,38 @@ export async function runRepl(opts) {
             session.last_object = extractedObject ?? previousObject ?? null;
             continue;
         }
+        // B3 (2026-06-06) — `/abap-plan --resume @plan-file` (classic-mode
+        // mirror of the Ink path above; see that block for the full design
+        // note). Token-free pre-work; terminal states end the turn with no
+        // model call; otherwise the prepared bounded prompt falls through to
+        // runTurn with suppressSaveHook, and finishPlanResume persists the
+        // envelope revision after the turn.
+        let planResume = null;
+        let planResumeMsgStart = 0;
+        if (skill === 'abap-plan' && /(^|\s)--resume(\s|$)/.test(prompt)) {
+            try {
+                const { preparePlanResume } = await import('./commands/plan-resume.js');
+                planResume = await preparePlanResume({
+                    body: prompt,
+                    cwd: process.cwd(),
+                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                });
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[--resume] ${err.message}\n`));
+            }
+            if (!planResume) {
+                session.last_skill = previousSkill ?? null;
+                session.last_object = extractedObject ?? previousObject ?? null;
+                continue;
+            }
+            planResumeMsgStart = session.messages.length;
+            prompt = planResume.llmPrompt;
+        }
+        // 2026-06-08 — manifest-on-interrupt (classic path). See the Ink path for
+        // the full rationale; persist the revision mid-turn so a Ctrl+C can't lose it.
+        let planSavedEarly = false;
+        const planResumeForHook = planResume;
         const turnStart = Date.now();
         // H1 — `session.usage` is session-LIFETIME (initialised once in
         // newSession, saved across turns). The footer's "this turn" label was
@@ -1675,6 +1821,25 @@ export async function runRepl(opts) {
                 skill: skill,
                 ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                 signal: turnAbort.signal,
+                suppressSaveHook: planResume !== null,
+                onPlanManifest: planResumeForHook
+                    ? async (assistantText) => {
+                        try {
+                            const { finishPlanResume } = await import('./commands/plan-resume.js');
+                            await finishPlanResume({
+                                prepared: planResumeForHook,
+                                messages: session.messages,
+                                messagesStart: planResumeMsgStart,
+                                log: (...lines) => lines.forEach((l) => console.log(l)),
+                                textOverride: assistantText,
+                            });
+                            planSavedEarly = true;
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
+                        }
+                    }
+                    : undefined,
             });
         }
         catch (err) {
@@ -1694,6 +1859,23 @@ export async function runRepl(opts) {
             rl.removeListener('SIGINT', onSigint);
             turnInProgress = false;
         }
+        // B3 — persist the plan revision from the resume turn's manifest block.
+        // FALLBACK: skipped when the mid-turn onPlanManifest hook already saved it
+        // (manifest-on-interrupt, 2026-06-08); still runs when no manifest streamed.
+        if (planResume && !planSavedEarly) {
+            try {
+                const { finishPlanResume } = await import('./commands/plan-resume.js');
+                await finishPlanResume({
+                    prepared: planResume,
+                    messages: session.messages,
+                    messagesStart: planResumeMsgStart,
+                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                });
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
+            }
+        }
         // 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.

package/dist/skill-catalog.js

@@ -1,8 +1,8 @@
 /**
  * Static skill catalog for CSPeach CLI v0.2.
  *
- * STALENESS RISK (spec §3.3): This constant is hardcoded against the 33 skills
- * in .claude/skills/ as of 2026-04-19. It will drift if skills are added or
+ * STALENESS RISK (spec §3.3): This constant is hardcoded against the 34 skills
+ * in .claude/skills/ as of 2026-06-06 (abap-plan added). It will drift if skills are added or
  * removed. At Plan 4b kickoff decision the build-time generation option
  * (scripts/generate-skill-catalog.ts reads SKILL.md frontmatter) or runtime
  * fetch (/v1/skills endpoint) will be chosen to replace this file. Until then,
@@ -219,4 +219,10 @@ export const SKILL_CATALOG = [
         description: 'Effort estimation for ABAP tickets — component breakdown with hour ranges (optimistic / realistic / pessimistic) + risk adjustments',
         whenToUse: `pick this for hour ranges + risk adjustments on a confirmed object list (step 3 of 3 — needs /abap-design first; high uncertainty without it)`,
     },
+    {
+        name: 'abap-plan',
+        category: 'Pre-Coding',
+        description: 'Multi-session project plan — phase envelope holds state across sessions; create from a goal or spec-gap file, resume one bounded phase per session',
+        whenToUse: `pick this when the work spans multiple sessions or components (not /abap-design — that's one design in one session; plan calls design per phase)`,
+    },
 ];

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/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));