praxis-agent 0.1.2 → 0.3.0

package/dist/cli/interactive.js

@@ -1,7 +1,101 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, render, useApp, useInput } from 'ink';
 import { redactSensitiveText, sensitiveEnvironmentValues, } from '../platform/sensitive-data.js';
+import { CommandPalette, Composer, DiffDashboard, DialogFrame, ExternalEditorWait, HelpMenu, ListDashboard, MentionPicker, PermissionDashboard, SelectionMenu, SessionPicker, StatusDashboard, Transcript, WelcomePanel, useTerminalWidth, } from './tui/claude-style.js';
+import { loadGitDiff, visiblePatchLines, } from './tui/git-diff.js';
+import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule, } from './tui/permission-settings.js';
+import { filterTuiSlashCommands, mergeTuiSlashCommands, slashCommandQuery, } from './tui/slash-commands.js';
+import { createComposerEditor, deleteComposerToEnd, deleteComposerToStart, deleteComposerWordBackward, insertComposerText, moveComposerCursorByWord, } from './tui/composer-editor.js';
+import { applyMentionReference, fileReferenceAtCursor, filterTuiMentionEntries, loadTuiFileEntries, } from './tui/file-picker.js';
+import { editTuiPrompt, openTuiEditorFile, } from './tui/external-editor.js';
+import { suspendTuiProcess } from './tui/terminal-suspend.js';
+import { readTuiClipboard, writeTuiClipboard, } from './tui/clipboard.js';
+import { composerImageIds, deleteComposerImageBackward, deleteComposerImageForward, insertComposerImageMarker, moveComposerCursorAcrossImages, } from './tui/composer-images.js';
+import { defaultTuiKeybindings, ensureTuiKeybindingsFile, hasTuiKeybindingPrefix, loadTuiKeybindings, resolveTuiKeybinding, tuiKeyChord, } from './tui/keybindings.js';
+import { completeTuiWorkspaceDirectory, resolveTuiWorkspaceDirectory, } from './tui/workspace-directories.js';
+import { conversationExportPath, conversationExportText, defaultConversationExportFilename, writeConversationExport, } from './tui/conversation-export.js';
+const EMPTY_SLASH_COMMANDS = [];
+const EMPTY_AGENTS = [];
+const EFFORT_OPTIONS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const PERMISSION_OPTIONS = [
+    {
+        mode: 'default',
+        label: 'Default',
+        description: 'Ask before changes that need approval.',
+    },
+    {
+        mode: 'acceptEdits',
+        label: 'Accept edits',
+        description: 'Allow file edits while keeping command approval.',
+    },
+    {
+        mode: 'auto',
+        label: 'Auto',
+        description: 'Classify safe tool calls before asking.',
+    },
+    {
+        mode: 'manual',
+        label: 'Manual',
+        description: 'Ask for every tool call that is not explicitly allowed.',
+    },
+    {
+        mode: 'dontAsk',
+        label: "Don't ask",
+        description: 'Deny tool calls that require confirmation.',
+    },
+    {
+        mode: 'plan',
+        label: 'Plan mode',
+        description: 'Restrict changes to the plan file until approval.',
+    },
+];
+function rewindActions(point) {
+    const shared = [
+        { action: 'summarize-from', label: 'Summarize from here' },
+        { action: 'summarize-to', label: 'Summarize up to here' },
+        { action: 'cancel', label: 'Never mind' },
+    ];
+    return point.fileRestoreAvailable && point.fileChanges.length > 0
+        ? [
+            {
+                action: 'code-and-conversation',
+                label: 'Restore code and conversation',
+            },
+            { action: 'conversation', label: 'Restore conversation' },
+            { action: 'code', label: 'Restore code' },
+            ...shared,
+        ]
+        : [{ action: 'conversation', label: 'Restore conversation' }, ...shared];
+}
+function rewindPointWindow(points, selectedIndex, size = 6) {
+    if (points.length <= size)
+        return { start: 0, end: points.length };
+    if (selectedIndex >= points.length) {
+        return { start: points.length - size, end: points.length };
+    }
+    const start = Math.max(0, Math.min(points.length - size, selectedIndex - Math.floor(size / 2)));
+    return { start, end: start + size };
+}
+function permissionMode(value) {
+    return [
+        'acceptEdits',
+        'auto',
+        'bypassPermissions',
+        'manual',
+        'dontAsk',
+        'plan',
+    ].includes(value ?? '')
+        ? value
+        : 'default';
+}
+function effort(value) {
+    return EFFORT_OPTIONS.includes(value)
+        ? value
+        : 'high';
+}
 function questionAnswer(question, input) {
     const answer = input.trim();
     if (!answer)
@@ -29,28 +123,157 @@ function questionAnswer(question, input) {
     })
         .join(', ');
 }
+function permissionDeleteTitle(behavior) {
+    return `Delete ${behavior === 'allow' ? 'allowed' : behavior === 'deny' ? 'denied' : 'ask'} tool?`;
+}
+function permissionScopeLabel(scope) {
+    return scope === 'local'
+        ? 'From project local settings'
+        : scope === 'project'
+            ? 'From project settings'
+            : 'From user settings';
+}
+function permissionRuleDescription(rule) {
+    const bashPrefix = /^Bash\((.*?)(?::\*| \*)\)$/u.exec(rule)?.[1]?.trim();
+    return bashPrefix ? `Any Bash command starting with ${bashPrefix}` : undefined;
+}
 function describeTool(call, sensitiveValues) {
     const name = redactSensitiveText(call.name, sensitiveValues);
+    return `${name} ${describeToolInput(call, sensitiveValues)}`;
+}
+function redactToolCall(call, sensitiveValues) {
+    return {
+        ...call,
+        name: redactSensitiveText(call.name, sensitiveValues),
+        input: JSON.parse(redactSensitiveText(JSON.stringify(call.input), sensitiveValues)),
+    };
+}
+function describeToolInput(call, sensitiveValues) {
     const detail = redactSensitiveText(JSON.stringify(call.input), sensitiveValues);
-    return `${name} ${detail.length > 160 ? `${detail.slice(0, 157)}...` : detail}`;
+    return detail.length > 160 ? `${detail.slice(0, 157)}...` : detail;
+}
+function filterSessionChoices(sessions, search) {
+    const query = search.trim().toLowerCase();
+    if (!query)
+        return sessions;
+    return sessions.filter((session) => {
+        if (!session)
+            return false;
+        return [session.sessionId, session.name, session.lastPrompt].some((value) => value?.toLowerCase().includes(query));
+    });
+}
+function estimatedCommandTokens(command) {
+    return Math.max(1, Math.ceil(`/${command.name} ${command.description}`.length / 4));
+}
+function workflowRows(workflows) {
+    return workflows.map((workflow) => ({
+        label: `${String(workflow.task_id ?? workflow.id ?? 'task')} [${String(workflow.status ?? 'unknown')}] ${String(workflow.summary ?? workflow.description ?? '')}`.trim(),
+    }));
 }
-export function InteractiveApp({ factory, initialSessions, initialPrompt, signal, onCancel, onTurnChange, onCleanup, axScreenReader = false, allowNewSession = true, resume, }) {
-    const { exit } = useApp();
+function ordinal(value) {
+    const remainder100 = value % 100;
+    if (remainder100 >= 11 && remainder100 <= 13)
+        return `${value}th`;
+    switch (value % 10) {
+        case 1:
+            return `${value}st`;
+        case 2:
+            return `${value}nd`;
+        case 3:
+            return `${value}rd`;
+        default:
+            return `${value}th`;
+    }
+}
+export function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory = [], signal, onCancel, onTurnChange, onCleanup, axScreenReader = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, exportWriter = writeConversationExport, permissionRuleStore, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, }) {
+    const { exit, suspendTerminal, waitUntilRenderFlush } = useApp();
+    const width = useTerminalWidth(terminalWidth);
+    const keybindingsRoot = useMemo(() => resolve(keybindingsConfigRoot ??
+        process.env.CLAUDE_CONFIG_DIR ??
+        resolve(homedir(), '.claude')), [keybindingsConfigRoot]);
     const sensitiveValues = useMemo(() => sensitiveEnvironmentValues(process.env), []);
+    const [runtimeCwd, setRuntimeCwd] = useState(display.cwd);
+    const runtimeCwdRef = useRef(display.cwd);
+    const loadDiffSnapshot = useMemo(() => diffLoader ?? (() => loadGitDiff(runtimeCwd)), [diffLoader, runtimeCwd]);
+    const loadFiles = useMemo(() => fileLoader ?? (() => loadTuiFileEntries(runtimeCwd)), [fileLoader, runtimeCwd]);
+    const permissionStore = useMemo(() => permissionRuleStore ?? {
+        load: () => loadTuiPermissionRules(runtimeCwd),
+        add: (input) => addTuiPermissionRule({ cwd: runtimeCwd, ...input }),
+        remove: removeTuiPermissionRule,
+    }, [permissionRuleStore, runtimeCwd]);
     const choices = useMemo(() => allowNewSession ? [null, ...initialSessions] : initialSessions, [allowNewSession, initialSessions]);
-    const [selectingSession, setSelectingSession] = useState(initialSessions.length > 0 && resume?.sessionId === undefined);
+    const [pickerIncludesNewSession, setPickerIncludesNewSession] = useState(allowNewSession);
+    const pickerIncludesNewSessionRef = useRef(allowNewSession);
+    const pickerChoices = pickerIncludesNewSession ? choices : initialSessions;
+    const [sessionSearch, setSessionSearch] = useState('');
+    const sessionSearchRef = useRef('');
+    const filteredPickerChoices = useMemo(() => filterSessionChoices(pickerChoices, sessionSearch), [pickerChoices, sessionSearch]);
+    const [selectingSession, setSelectingSession] = useState(initialSessions.length > 0 &&
+        resume?.sessionId === undefined &&
+        (!allowNewSession || resume?.requireSession === true));
     const [selectedIndex, setSelectedIndex] = useState(0);
     const selectedIndexRef = useRef(0);
     const [sessionId, setSessionId] = useState(resume?.sessionId ?? null);
     const [pendingFork, setPendingFork] = useState(resume?.forkSession === true);
     const [input, setInput] = useState('');
     const inputRef = useRef('');
+    const [inputCursor, setInputCursor] = useState(0);
+    const inputCursorRef = useRef(0);
+    const inputHistoryRef = useRef([]);
+    const inputHistoryIndexRef = useRef(null);
+    const inputHistoryDraftRef = useRef('');
+    const undoStackRef = useRef([]);
+    const composerImagesRef = useRef(new Map());
+    const nextImageIdRef = useRef(1);
+    const clipboardQueueRef = useRef(Promise.resolve());
+    const clipboardPendingRef = useRef(0);
+    const componentMountedRef = useRef(true);
+    const [clipboardBusy, setClipboardBusy] = useState(false);
+    const stashedInputRef = useRef('');
+    const lastEscapeAtRef = useRef(0);
+    const [commandPaletteOpen, setCommandPaletteOpen] = useState(false);
+    const [commandSelection, setCommandSelection] = useState(0);
+    const [filePickerOpen, setFilePickerOpen] = useState(false);
+    const [fileSelection, setFileSelection] = useState(0);
+    const [fileEntries, setFileEntries] = useState(null);
+    const [shortcutsVisible, setShortcutsVisible] = useState(false);
+    const [externalEditorRequest, setExternalEditorRequest] = useState(null);
+    const [keybindingsEditing, setKeybindingsEditing] = useState(false);
+    const [keybindings, setKeybindings] = useState(defaultTuiKeybindings);
+    const keySequenceRef = useRef(null);
+    const [processSuspendRequested, setProcessSuspendRequested] = useState(false);
+    const processSuspendRequestedRef = useRef(false);
+    const [editorFooterMessage, setEditorFooterMessage] = useState();
+    const [availableSlashCommands, setAvailableSlashCommands] = useState(slashCommands);
+    const [availableAgents, setAvailableAgents] = useState(agents);
+    const [menu, setMenu] = useState(null);
+    const menuRef = useRef(null);
     const [busy, setBusy] = useState(false);
+    const [compactProgress, setCompactProgress] = useState(0);
     const initialPromptRef = useRef(initialPrompt?.trim() ?? '');
     const [initialPromptPending, setInitialPromptPending] = useState(initialPromptRef.current.length > 0);
     const [status, setStatus] = useState('ready');
     const [activeText, setActiveText] = useState('');
-    const [history, setHistory] = useState([]);
+    const [activeThinking, setActiveThinking] = useState('');
+    const [thinkingExpanded, setThinkingExpanded] = useState(false);
+    const [usage, setUsage] = useState();
+    const [costUsd, setCostUsd] = useState();
+    const [contextWindowTokens, setContextWindowTokens] = useState(display.contextWindowTokens);
+    const [history, setHistory] = useState([...initialHistory]);
+    const sessionLoadRef = useRef(0);
+    const [turnDiffs, setTurnDiffs] = useState([]);
+    const turnNumberRef = useRef(0);
+    const turnMutatedFilesRef = useRef(false);
+    const permissionCallsRef = useRef(new Map());
+    const [recentDenied, setRecentDenied] = useState([]);
+    const [exitConfirmation, setExitConfirmation] = useState(false);
+    const exitConfirmationTimerRef = useRef(null);
+    const [runtimePreferences, setRuntimePreferences] = useState(() => ({
+        effort: effort(display.effort),
+        permissionMode: permissionMode(display.permissionMode),
+        additionalDirectories: [...new Set(additionalDirectories)],
+    }));
+    const runtimePreferencesRef = useRef(runtimePreferences);
     const [permission, setPermission] = useState(null);
     const permissionRef = useRef(null);
     const [elicitation, setElicitation] = useState(null);
@@ -64,6 +287,122 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
     const onCleanupRef = useRef(onCleanup);
     onCleanupRef.current = onCleanup;
     const scheduledWaitRef = useRef(null);
+    const turnControllerRef = useRef(null);
+    const serviceRetirementRef = useRef(null);
+    const serviceEpochRef = useRef(0);
+    const serviceCreationEpochRef = useRef(null);
+    const allSlashCommands = useMemo(() => mergeTuiSlashCommands(availableSlashCommands), [availableSlashCommands]);
+    const builtinSlashCommands = useMemo(() => allSlashCommands.filter((command) => command.source === 'builtin'), [allSlashCommands]);
+    const customSlashCommands = useMemo(() => allSlashCommands.filter((command) => command.source !== 'builtin'), [allSlashCommands]);
+    const commandQuery = commandPaletteOpen ? slashCommandQuery(input) : null;
+    const fileReference = filePickerOpen
+        ? fileReferenceAtCursor(input, inputCursor)
+        : null;
+    const shellMode = input.startsWith('!');
+    const matchingSlashCommands = useMemo(() => commandQuery === null
+        ? []
+        : filterTuiSlashCommands(allSlashCommands, commandQuery), [allSlashCommands, commandQuery]);
+    const commandPaletteVisible = !busy &&
+        !permission &&
+        !planApproval &&
+        !question &&
+        !elicitation &&
+        !selectingSession &&
+        commandQuery !== null;
+    const matchingMentionEntries = useMemo(() => fileEntries === null || fileReference === null
+        ? []
+        : filterTuiMentionEntries(fileEntries, availableAgents, fileReference.query), [availableAgents, fileEntries, fileReference?.query]);
+    const filePickerVisible = !busy &&
+        !permission &&
+        !planApproval &&
+        !question &&
+        !elicitation &&
+        !selectingSession &&
+        filePickerOpen &&
+        !shellMode &&
+        fileReference !== null;
+    const selectedFileIndex = Math.min(fileSelection, Math.max(0, matchingMentionEntries.length - 1));
+    const hasThinking = activeThinking.length > 0 ||
+        history.some((item) => item.kind === 'thinking');
+    const hasDetailedTranscript = hasThinking ||
+        history.some((item) => item.kind === 'tool' ||
+            item.kind === 'shell' ||
+            item.kind === 'compact');
+    const selectedSlashCommandIndex = Math.min(commandSelection, Math.max(0, matchingSlashCommands.length - 1));
+    const runtimeDisplay = {
+        ...display,
+        cwd: runtimeCwd,
+        ...(runtimePreferences.model === undefined
+            ? {}
+            : { model: runtimePreferences.model }),
+        effort: runtimePreferences.effort,
+        permissionMode: runtimePreferences.permissionMode,
+        ...(contextWindowTokens === undefined ? {} : { contextWindowTokens }),
+    };
+    const workspaceDirectories = [
+        runtimeCwd,
+        ...runtimePreferences.additionalDirectories.filter((path) => path !== runtimeCwd),
+    ].map((path) => ({ path, original: path === runtimeCwd }));
+    const permissionOptions = useMemo(() => [
+        ...PERMISSION_OPTIONS,
+        ...(allowDangerouslySkipPermissions
+            ? [
+                {
+                    mode: 'bypassPermissions',
+                    label: 'Bypass permissions',
+                    description: 'Allow tool calls except explicit deny rules for this session.',
+                },
+            ]
+            : []),
+    ], [allowDangerouslySkipPermissions]);
+    const modelOptions = useMemo(() => [
+        {
+            label: runtimeDisplay.model
+                ? `Current: ${runtimeDisplay.model}`
+                : 'Current: provider default',
+            description: 'Keep the model selected for this interactive session.',
+            selected: true,
+        },
+        {
+            label: 'Use invocation default',
+            description: 'Use the model supplied by the original CLI invocation.',
+        },
+        {
+            label: 'Enter a model ID…',
+            description: 'Use any model identifier supported by the configured provider.',
+        },
+    ], [runtimeDisplay.model]);
+    useEffect(() => {
+        setAvailableSlashCommands(slashCommands);
+    }, [slashCommands]);
+    useEffect(() => {
+        setAvailableAgents(agents);
+    }, [agents]);
+    useEffect(() => {
+        if (!commandPaletteOpen)
+            return;
+        const currentCommands = serviceRef.current?.slashCommands?.();
+        if (currentCommands)
+            setAvailableSlashCommands(currentCommands);
+    }, [commandPaletteOpen]);
+    useEffect(() => {
+        setFileEntries(null);
+    }, [loadFiles]);
+    useEffect(() => {
+        if (!filePickerVisible || fileEntries !== null)
+            return;
+        let cancelled = false;
+        void loadFiles().then((entries) => {
+            if (!cancelled)
+                setFileEntries(entries);
+        }, () => {
+            if (!cancelled)
+                setFileEntries([]);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [fileEntries, filePickerVisible, loadFiles]);
     useEffect(() => {
         if (!signal)
             return;
@@ -81,11 +420,15 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
         return () => signal.removeEventListener('abort', cancel);
     }, [exit, signal]);
     useEffect(() => () => {
+        componentMountedRef.current = false;
         permissionRef.current?.resolve(false);
         elicitationRef.current?.resolve({ action: 'cancel' });
         questionRef.current?.resolve(null);
         planApprovalRef.current?.resolve(false);
+        if (exitConfirmationTimerRef.current)
+            clearTimeout(exitConfirmationTimerRef.current);
         scheduledWaitRef.current?.abort();
+        turnControllerRef.current?.abort();
         const closing = serviceRef.current?.close?.() ?? Promise.resolve();
         if (onCleanupRef.current)
             onCleanupRef.current(closing);
@@ -93,33 +436,407 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
             void closing.catch(() => undefined);
     }, []);
     const append = (line) => setHistory((current) => [...current, line]);
-    const handleEvent = (event) => {
-        if (event.type === 'text-delta') {
-            setActiveText((current) => current + event.delta);
-        }
-        else if (event.type === 'user-message') {
-            append({ kind: 'assistant', text: event.message });
-        }
-        else if (event.type === 'state') {
-            setStatus(event.state);
+    useEffect(() => {
+        let cancelled = false;
+        void keybindingsLoader(keybindingsRoot).then((loaded) => {
+            if (!cancelled)
+                setKeybindings(loaded);
+        }, (error) => {
+            if (!cancelled)
+                append({
+                    kind: 'warning',
+                    text: error instanceof Error ? error.message : String(error),
+                });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [keybindingsRoot, keybindingsLoader]);
+    const updateComposerInput = (next, cursor) => {
+        const editor = createComposerEditor(next, cursor);
+        inputRef.current = editor.text;
+        inputCursorRef.current = editor.cursor;
+        setInput(editor.text);
+        setInputCursor(editor.cursor);
+        setShortcutsVisible(false);
+        setCommandPaletteOpen(slashCommandQuery(editor.text) !== null);
+        setCommandSelection(0);
+        setFilePickerOpen(fileReferenceAtCursor(editor.text, editor.cursor) !== null);
+        setFileSelection(0);
+    };
+    const updateComposerEditor = (editor, recordUndo = true) => {
+        if (recordUndo && editor.text !== inputRef.current) {
+            undoStackRef.current = [
+                ...undoStackRef.current,
+                createComposerEditor(inputRef.current, inputCursorRef.current),
+            ].slice(-100);
         }
-        else if (event.type === 'tool-call') {
-            append({
-                kind: 'notice',
-                text: `Tool: ${describeTool(event.call, sensitiveValues)}`,
+        updateComposerInput(editor.text, editor.cursor);
+    };
+    const clearComposerInput = () => updateComposerInput('');
+    const promptImages = (prompt) => {
+        const seen = new Set();
+        return composerImageIds(prompt).flatMap((id) => {
+            if (seen.has(id))
+                return [];
+            seen.add(id);
+            const image = composerImagesRef.current.get(id);
+            return image ? [image] : [];
+        });
+    };
+    const pasteClipboard = () => {
+        clipboardPendingRef.current += 1;
+        setClipboardBusy(true);
+        const paste = clipboardQueueRef.current.then(async () => {
+            if (!componentMountedRef.current)
+                return;
+            const content = await clipboardReader();
+            if (!componentMountedRef.current)
+                return;
+            if (content.kind === 'text') {
+                updateComposerEditor(insertComposerText(createComposerEditor(inputRef.current, inputCursorRef.current), content.text));
+            }
+            else if (content.kind === 'image') {
+                const id = nextImageIdRef.current;
+                nextImageIdRef.current += 1;
+                composerImagesRef.current.set(id, content.image);
+                updateComposerEditor(insertComposerImageMarker(createComposerEditor(inputRef.current, inputCursorRef.current), id));
+            }
+        });
+        clipboardQueueRef.current = paste.catch(() => undefined);
+        void paste
+            .catch((error) => {
+            if (!componentMountedRef.current)
+                return;
+            setEditorFooterMessage({
+                text: error instanceof Error ? error.message : String(error),
+                isError: true,
             });
+        })
+            .finally(() => {
+            clipboardPendingRef.current -= 1;
+            if (componentMountedRef.current && clipboardPendingRef.current === 0)
+                setClipboardBusy(false);
+        });
+    };
+    useEffect(() => {
+        if (externalEditorRequest === null)
+            return;
+        const editing = (async () => {
+            try {
+                await waitUntilRenderFlush();
+                let result;
+                await suspendTerminal(async () => {
+                    result = await externalEditor(externalEditorRequest.prompt, {
+                        cwd: runtimeCwdRef.current,
+                        ...(signal === undefined ? {} : { signal }),
+                    });
+                });
+                if (!result)
+                    throw new Error('External editor returned no content');
+                updateComposerEditor(createComposerEditor(result.content));
+                setEditorFooterMessage({
+                    text: `ctrl+g to edit in ${result.editorName}`,
+                    isError: false,
+                });
+            }
+            catch (error) {
+                setEditorFooterMessage({
+                    text: error instanceof Error ? error.message : String(error),
+                    isError: true,
+                });
+            }
+            finally {
+                setExternalEditorRequest(null);
+            }
+        })();
+        onTurnChange?.(editing);
+        void editing.finally(() => onTurnChange?.(null));
+    }, [externalEditorRequest]);
+    useEffect(() => {
+        if (!keybindingsEditing)
+            return;
+        const editing = (async () => {
+            try {
+                const file = await keybindingsFile(keybindingsRoot);
+                await waitUntilRenderFlush();
+                await suspendTerminal(async () => {
+                    await keybindingsEditor(file.path, {
+                        cwd: runtimeCwdRef.current,
+                        ...(signal === undefined ? {} : { signal }),
+                    });
+                });
+                append({
+                    kind: 'local-result',
+                    text: file.created
+                        ? `Created ${file.path} with template. Opened in your editor.`
+                        : `Opened ${file.path} in your editor.`,
+                });
+                try {
+                    setKeybindings(await keybindingsLoader(keybindingsRoot));
+                }
+                catch (error) {
+                    append({
+                        kind: 'warning',
+                        text: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            catch (error) {
+                append({
+                    kind: 'warning',
+                    text: error instanceof Error ? error.message : String(error),
+                });
+            }
+            finally {
+                setKeybindingsEditing(false);
+            }
+        })();
+        onTurnChange?.(editing);
+        void editing.finally(() => onTurnChange?.(null));
+    }, [keybindingsEditing]);
+    useEffect(() => {
+        if (!processSuspendRequested)
+            return;
+        void (async () => {
+            try {
+                await waitUntilRenderFlush();
+                await suspendTerminal(suspendProcess);
+            }
+            catch (error) {
+                append({
+                    kind: 'warning',
+                    text: error instanceof Error ? error.message : String(error),
+                });
+            }
+            finally {
+                processSuspendRequestedRef.current = false;
+                setProcessSuspendRequested(false);
+            }
+        })();
+    }, [processSuspendRequested]);
+    const updateMenu = (next) => {
+        menuRef.current = next;
+        setMenu(next);
+    };
+    useEffect(() => {
+        if (menu?.kind !== 'compact-progress')
+            return;
+        const startedAt = Date.now();
+        const timer = setInterval(() => {
+            setCompactProgress(Math.min(99, Math.max(1, Math.floor((Date.now() - startedAt) / 250))));
+        }, 250);
+        return () => clearInterval(timer);
+    }, [menu?.kind]);
+    const appendPromptHistory = (prompt) => {
+        if (!prompt)
+            return;
+        const history = inputHistoryRef.current.filter((item) => item !== prompt);
+        inputHistoryRef.current = [prompt, ...history].slice(0, 100);
+        inputHistoryIndexRef.current = null;
+        inputHistoryDraftRef.current = '';
+    };
+    const restorePromptHistory = (direction) => {
+        const history = inputHistoryRef.current;
+        if (history.length === 0)
+            return;
+        const currentIndex = inputHistoryIndexRef.current;
+        if (direction === 'previous') {
+            if (currentIndex === null)
+                inputHistoryDraftRef.current = inputRef.current;
+            const nextIndex = Math.min(history.length - 1, (currentIndex ?? -1) + 1);
+            inputHistoryIndexRef.current = nextIndex;
+            updateComposerInput(history[nextIndex] ?? '');
+            return;
         }
-        else if (event.type === 'tool-result' && event.isError) {
-            append({
-                kind: 'warning',
-                text: `Tool failed: ${redactSensitiveText(event.content, sensitiveValues)}`,
-            });
+        if (currentIndex === null)
+            return;
+        const nextIndex = currentIndex - 1;
+        if (nextIndex < 0) {
+            inputHistoryIndexRef.current = null;
+            updateComposerInput(inputHistoryDraftRef.current);
+            return;
         }
-        else if (event.type === 'warning' || event.type === 'failed') {
-            append({
-                kind: 'warning',
-                text: redactSensitiveText(event.message, sensitiveValues),
-            });
+        inputHistoryIndexRef.current = nextIndex;
+        updateComposerInput(history[nextIndex] ?? '');
+    };
+    const dismissExitConfirmation = () => {
+        if (!exitConfirmation)
+            return;
+        if (exitConfirmationTimerRef.current)
+            clearTimeout(exitConfirmationTimerRef.current);
+        exitConfirmationTimerRef.current = null;
+        setExitConfirmation(false);
+    };
+    const armExitConfirmation = () => {
+        if (exitConfirmation) {
+            permissionRef.current?.resolve(false);
+            elicitationRef.current?.resolve({ action: 'cancel' });
+            questionRef.current?.resolve(null);
+            planApprovalRef.current?.resolve(false);
+            onCancel?.();
+            exit();
+            return;
+        }
+        clearComposerInput();
+        setExitConfirmation(true);
+        if (exitConfirmationTimerRef.current)
+            clearTimeout(exitConfirmationTimerRef.current);
+        exitConfirmationTimerRef.current = setTimeout(() => {
+            exitConfirmationTimerRef.current = null;
+            setExitConfirmation(false);
+        }, 1_500);
+    };
+    useEffect(() => {
+        setCommandSelection((current) => Math.min(current, Math.max(0, matchingSlashCommands.length - 1)));
+    }, [matchingSlashCommands.length]);
+    useEffect(() => {
+        setFileSelection((current) => Math.min(current, Math.max(0, matchingMentionEntries.length - 1)));
+    }, [matchingMentionEntries.length]);
+    const handleEvent = (event) => {
+        switch (event.type) {
+            case 'text-delta':
+                setActiveText((current) => current + event.delta);
+                break;
+            case 'thinking-start':
+                setActiveThinking(event.block.type === 'thinking'
+                    ? redactSensitiveText(event.block.thinking, sensitiveValues)
+                    : '');
+                break;
+            case 'thinking-delta':
+                setActiveThinking((current) => current + redactSensitiveText(event.delta, sensitiveValues));
+                break;
+            case 'thinking-signature-delta':
+                // Signatures authenticate a thinking block for provider replay; they are
+                // intentionally not part of the user-visible reasoning summary.
+                break;
+            case 'thinking-stop':
+                append({
+                    kind: 'thinking',
+                    text: event.block.type === 'thinking'
+                        ? redactSensitiveText(event.block.thinking, sensitiveValues)
+                        : activeThinking,
+                });
+                setActiveThinking('');
+                break;
+            case 'user-message':
+                append({ kind: 'assistant', text: event.message });
+                break;
+            case 'state':
+                setStatus(event.state);
+                break;
+            case 'usage':
+                setUsage(event.usage);
+                break;
+            case 'tool-call':
+                if (['Edit', 'Write', 'NotebookEdit'].includes(event.call.name))
+                    turnMutatedFilesRef.current = true;
+                permissionCallsRef.current.set(event.call.id, describeTool(event.call, sensitiveValues));
+                append({
+                    kind: 'tool',
+                    call: redactToolCall(event.call, sensitiveValues),
+                    detail: describeToolInput(event.call, sensitiveValues),
+                });
+                break;
+            case 'permission-decision':
+                if (event.behavior === 'deny') {
+                    const denied = permissionCallsRef.current.get(event.callId) ?? event.callId;
+                    setRecentDenied((current) => [denied, ...current.filter((item) => item !== denied)].slice(0, 20));
+                }
+                append({
+                    kind: event.behavior === 'deny' ? 'warning' : 'notice',
+                    text: event.behavior === 'ask'
+                        ? `Permission confirmation required · ${event.callId}`
+                        : `Permission ${event.behavior === 'allow' ? 'allowed' : 'denied'} · ${event.callId}`,
+                });
+                break;
+            case 'tool-result':
+                append({
+                    kind: 'tool-result',
+                    callId: event.callId,
+                    text: redactSensitiveText(event.content, sensitiveValues),
+                    isError: event.isError,
+                });
+                break;
+            case 'shell-command':
+                append({
+                    kind: 'shell',
+                    callId: event.callId,
+                    command: redactSensitiveText(event.command, sensitiveValues),
+                });
+                break;
+            case 'shell-result':
+                append({
+                    kind: 'shell-result',
+                    callId: event.callId,
+                    stdout: redactSensitiveText(event.stdout, sensitiveValues),
+                    stderr: redactSensitiveText(event.stderr, sensitiveValues),
+                    isError: event.isError,
+                });
+                break;
+            case 'shell-cancelled':
+                setHistory((current) => current.filter((item) => !((item.kind === 'shell' || item.kind === 'shell-result') &&
+                    item.callId === event.callId)));
+                break;
+            case 'tool-progress':
+                setStatus(`${event.toolName} · ${event.elapsedTimeSeconds}s`);
+                break;
+            case 'task-started':
+                append({ kind: 'notice', text: `Task started · ${event.description}` });
+                break;
+            case 'task-progress':
+                setStatus(event.summary ?? event.description);
+                break;
+            case 'task-notification':
+                append({
+                    kind: event.status === 'failed' ? 'warning' : 'notice',
+                    text: `Task ${event.status} · ${event.summary}`,
+                });
+                break;
+            case 'compact-boundary':
+                append({
+                    kind: 'notice',
+                    text: `Conversation compacted · ${event.preTokens} tokens`,
+                });
+                break;
+            case 'api-retry':
+                append({
+                    kind: 'warning',
+                    text: `API retry ${event.attempt}/${event.maxRetries} · ${event.error}`,
+                });
+                break;
+            case 'elicitation-complete':
+                append({
+                    kind: 'notice',
+                    text: `MCP elicitation completed · ${event.mcpServerName}`,
+                });
+                break;
+            case 'tool-use-summary':
+                append({ kind: 'notice', text: event.summary });
+                break;
+            case 'hook': {
+                const { event: hook } = event;
+                const outcome = hook.outcome ? ` · ${hook.outcome}` : '';
+                append({
+                    kind: hook.outcome === 'error' ? 'warning' : 'notice',
+                    text: `Hook ${hook.type} · ${hook.hookName}${outcome}`,
+                });
+                break;
+            }
+            case 'session-state-changed':
+                setStatus(event.state.replace('_', ' '));
+                break;
+            case 'warning':
+            case 'failed':
+                append({
+                    kind: 'warning',
+                    text: redactSensitiveText(event.message, sensitiveValues),
+                });
+                break;
+            default: {
+                const unreachable = event;
+                return unreachable;
+            }
         }
     };
     const requestApproval = (call, kind) => new Promise((resolveApproval) => {
@@ -182,8 +899,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
             return;
         }
         signal?.addEventListener('abort', abort, { once: true });
-        inputRef.current = '';
-        setInput('');
+        clearComposerInput();
         questionRef.current = pending;
         setQuestion(pending);
     });
@@ -211,62 +927,728 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
         planApprovalRef.current = pending;
         setPlanApproval(pending);
     });
+    const warn = (error) => append({
+        kind: 'warning',
+        text: redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues),
+    });
+    const retireService = () => {
+        serviceEpochRef.current += 1;
+        scheduledWaitRef.current?.abort();
+        const current = serviceRef.current;
+        serviceRef.current = null;
+        if (!current?.close)
+            return Promise.resolve();
+        const closing = current.close().catch((error) => {
+            warn(error);
+        });
+        serviceRetirementRef.current = closing;
+        void closing.finally(() => {
+            if (serviceRetirementRef.current === closing)
+                serviceRetirementRef.current = null;
+        });
+        return closing;
+    };
+    const updateRuntimePreferences = (update) => {
+        const next = update(runtimePreferencesRef.current);
+        runtimePreferencesRef.current = next;
+        setRuntimePreferences(next);
+        return next;
+    };
     const service = async () => {
         if (serviceRef.current)
             return serviceRef.current;
-        const pending = serviceCreationRef.current ??
-            factory.createService({
-                eventSink: handleEvent,
-                requireProvider: true,
-                approveRecovery,
-                approveTool,
-                onElicitation: requestElicitation,
-                askUser,
-                approvePlan,
-                ...(signal ? { signal } : {}),
-            });
-        serviceCreationRef.current = pending;
+        let pending = serviceCreationRef.current;
+        let epoch = serviceCreationEpochRef.current;
+        if (!pending) {
+            epoch = serviceEpochRef.current;
+            const preferences = runtimePreferencesRef.current;
+            pending = (async () => {
+                await serviceRetirementRef.current;
+                return factory.createService({
+                    eventSink: handleEvent,
+                    requireProvider: true,
+                    approveRecovery,
+                    approveTool,
+                    onElicitation: requestElicitation,
+                    askUser,
+                    approvePlan,
+                    ...(preferences.model === undefined
+                        ? {}
+                        : { model: preferences.model }),
+                    effort: preferences.effort,
+                    permissionMode: preferences.permissionMode,
+                    additionalDirectories: preferences.additionalDirectories,
+                    cwd: runtimeCwdRef.current,
+                    ...(signal ? { signal } : {}),
+                });
+            })();
+            serviceCreationRef.current = pending;
+            serviceCreationEpochRef.current = epoch;
+        }
         try {
             const created = await pending;
+            if (epoch !== serviceEpochRef.current) {
+                try {
+                    await created.close?.();
+                }
+                catch (error) {
+                    warn(error);
+                }
+                if (serviceCreationRef.current === pending) {
+                    serviceCreationRef.current = undefined;
+                    serviceCreationEpochRef.current = null;
+                }
+                return service();
+            }
             serviceRef.current = created;
+            setAvailableSlashCommands(created.slashCommands?.() ?? slashCommands);
+            setAvailableAgents(created.agentDefinitions?.() ?? agents);
+            const runtimeInfo = created.runtimeInfo?.();
+            if (runtimeInfo?.contextWindowTokens !== undefined)
+                setContextWindowTokens(runtimeInfo.contextWindowTokens);
             return created;
         }
         finally {
-            serviceCreationRef.current = undefined;
+            if (serviceCreationRef.current === pending) {
+                serviceCreationRef.current = undefined;
+                serviceCreationEpochRef.current = null;
+            }
+        }
+    };
+    const openSession = (nextSessionId) => {
+        setSessionId(nextSessionId);
+        const loadId = sessionLoadRef.current + 1;
+        sessionLoadRef.current = loadId;
+        if (nextSessionId === null) {
+            setHistory([]);
+            return;
+        }
+        const loading = (async () => {
+            try {
+                const commands = await service();
+                const transcript = await commands.transcript?.(nextSessionId);
+                if (sessionLoadRef.current === loadId) {
+                    setHistory(transcript ? [...transcript] : []);
+                }
+            }
+            catch (error) {
+                if (sessionLoadRef.current === loadId)
+                    warn(error);
+            }
+        })();
+        onTurnChange?.(loading);
+        void loading.finally(() => onTurnChange?.(null));
+    };
+    const changeModel = (model) => {
+        updateRuntimePreferences((current) => {
+            if (model !== undefined)
+                return { ...current, model };
+            const withoutModel = { ...current };
+            delete withoutModel.model;
+            return withoutModel;
+        });
+        void retireService();
+        append({
+            kind: 'notice',
+            text: model
+                ? `Model set to ${model} for this session.`
+                : 'Model reset to the invocation default for this session.',
+        });
+    };
+    const changeEffort = (nextEffort) => {
+        updateRuntimePreferences((current) => ({ ...current, effort: nextEffort }));
+        void retireService();
+        append({
+            kind: 'notice',
+            text: `Effort set to ${nextEffort} for this session.`,
+        });
+    };
+    const changePermissionMode = (mode) => {
+        updateRuntimePreferences((current) => ({
+            ...current,
+            permissionMode: mode,
+        }));
+        const change = (async () => {
+            setBusy(true);
+            setStatus('updating permission mode');
+            try {
+                if (sessionId) {
+                    const commands = await service();
+                    if (!commands.setPermissionMode) {
+                        throw new Error('This interactive service cannot persist permission mode changes.');
+                    }
+                    await commands.setPermissionMode(sessionId, mode);
+                }
+                await retireService();
+                append({
+                    kind: 'notice',
+                    text: `Permission mode set to ${mode} for this session.`,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(change);
+        void change.finally(() => onTurnChange?.(null));
+    };
+    const openTasks = () => {
+        const loading = (async () => {
+            setBusy(true);
+            setStatus('loading tasks');
+            try {
+                const rows = workflowRows((await service()).workflows?.() ?? []);
+                updateMenu({
+                    kind: 'list',
+                    title: 'Background',
+                    rows,
+                    emptyText: 'No tasks currently running',
+                    selectedIndex: 0,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(loading);
+        void loading.finally(() => onTurnChange?.(null));
+    };
+    const openWorkspaceDirectoryInput = () => {
+        const loading = (async () => {
+            setBusy(true);
+            try {
+                updateMenu({
+                    kind: 'workspace-directory-input',
+                    rules: await permissionStore.load(),
+                    returnToPermissions: false,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+            }
+        })();
+        onTurnChange?.(loading);
+        void loading.finally(() => onTurnChange?.(null));
+    };
+    const copyResponse = (position) => {
+        const response = [...history]
+            .reverse()
+            .filter((item) => item.kind === 'assistant')[position - 1];
+        if (!response) {
+            append({
+                kind: 'warning',
+                text: `No ${position === 1 ? '' : `${ordinal(position)}-latest `}response to copy.`,
+            });
+            return;
+        }
+        const copying = clipboardWriter(response.text).then(() => append({
+            kind: 'local-result',
+            text: `Copied ${position === 1 ? 'last' : `${ordinal(position)}-latest`} response to clipboard.`,
+        }), (error) => warn(error));
+        onTurnChange?.(copying);
+        void copying.finally(() => onTurnChange?.(null));
+    };
+    const exportConversation = (method) => {
+        if (method === 'file') {
+            updateComposerInput(defaultConversationExportFilename());
+            updateMenu({ kind: 'export-filename' });
+            return;
+        }
+        const text = conversationExportText(runtimeDisplay, history);
+        const copying = clipboardWriter(text).then(() => {
+            updateMenu(null);
+            append({
+                kind: 'local-result',
+                text: 'Conversation copied to clipboard',
+            });
+        }, (error) => warn(error));
+        onTurnChange?.(copying);
+        void copying.finally(() => onTurnChange?.(null));
+    };
+    const saveConversation = (filename) => {
+        let path;
+        try {
+            path = conversationExportPath(runtimeCwdRef.current, filename);
+        }
+        catch (error) {
+            warn(error);
+            return;
+        }
+        const text = conversationExportText(runtimeDisplay, history);
+        const saving = exportWriter(path, text).then(() => {
+            clearComposerInput();
+            updateMenu(null);
+            append({
+                kind: 'local-result',
+                text: `Conversation exported to: ${path}`,
+            });
+        }, (error) => warn(error));
+        onTurnChange?.(saving);
+        void saving.finally(() => onTurnChange?.(null));
+    };
+    const reloadExtensions = (kind) => {
+        const loading = (async () => {
+            setBusy(true);
+            setStatus(`reloading ${kind}`);
+            try {
+                await retireService();
+                await service();
+                append({
+                    kind: 'local-result',
+                    text: `${kind === 'plugins' ? 'Plugin changes activated' : 'Skills reloaded'} for this session.`,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(loading);
+        void loading.finally(() => onTurnChange?.(null));
+    };
+    const openMcpServers = () => {
+        const loading = (async () => {
+            setBusy(true);
+            setStatus('loading MCP servers');
+            try {
+                const servers = (await service()).runtimeInfo?.().mcpServers ?? [];
+                updateMenu({
+                    kind: 'list',
+                    title: 'MCP servers',
+                    rows: servers.map((server) => ({
+                        label: server.name,
+                        description: server.status,
+                    })),
+                    emptyText: 'No MCP servers configured',
+                    selectedIndex: 0,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(loading);
+        void loading.finally(() => onTurnChange?.(null));
+    };
+    const changeWorkingDirectory = (requestedCwd) => {
+        const changing = (async () => {
+            setBusy(true);
+            setStatus('changing directory');
+            try {
+                const commands = await service();
+                if (!commands.changeCwd) {
+                    throw new Error('This interactive service cannot change working directories.');
+                }
+                const cwd = await commands.changeCwd(sessionId ?? undefined, requestedCwd);
+                runtimeCwdRef.current = cwd;
+                setRuntimeCwd(cwd);
+                await retireService();
+                append({ kind: 'local-result', text: `Moved to ${cwd}` });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(changing);
+        void changing.finally(() => onTurnChange?.(null));
+    };
+    const showCdUsage = () => {
+        const showing = (async () => {
+            try {
+                if (sessionId)
+                    await (await service()).recordCdUsage?.(sessionId);
+                append({ kind: 'local-result', text: 'Usage: /cd <path>' });
+            }
+            catch (error) {
+                warn(error);
+            }
+        })();
+        onTurnChange?.(showing);
+        void showing.finally(() => onTurnChange?.(null));
+    };
+    const renameSession = (requestedName) => {
+        const renaming = (async () => {
+            if (!sessionId) {
+                append({ kind: 'warning', text: 'No active conversation to rename.' });
+                return;
+            }
+            setBusy(true);
+            setStatus('renaming session');
+            try {
+                const commands = await service();
+                if (!commands.rename) {
+                    throw new Error('This interactive service cannot rename sessions.');
+                }
+                const name = requestedName?.trim() ||
+                    (await commands.sessionNameSuggestion?.(sessionId, signal));
+                if (!name)
+                    throw new Error('Could not generate a session name');
+                await commands.rename(sessionId, name);
+                append({ kind: 'local-result', text: `Session renamed to: ${name}` });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(renaming);
+        void renaming.finally(() => onTurnChange?.(null));
+    };
+    const branchSession = () => {
+        const branching = (async () => {
+            if (!sessionId) {
+                append({ kind: 'warning', text: 'No active conversation to branch.' });
+                return;
+            }
+            setBusy(true);
+            setStatus('branching conversation');
+            try {
+                const commands = await service();
+                const originalSessionId = sessionId;
+                const source = (await commands.sessions()).find((candidate) => candidate.sessionId === originalSessionId);
+                const fork = await commands.fork(originalSessionId);
+                const branchName = source?.name ? `${source.name} (Branch)` : undefined;
+                if (branchName && commands.rename) {
+                    await commands.rename(fork.sessionId, branchName);
+                }
+                setSessionId(fork.sessionId);
+                setPendingFork(false);
+                append({
+                    kind: 'local-result',
+                    text: `Branched conversation. You are now in the new branch (session ${fork.sessionId}). Use /resume ${originalSessionId}${source?.name ? ` ("${source.name}")` : ''} to return to the original, or run praxis -r ${originalSessionId} in a new terminal.`,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(branching);
+        void branching.finally(() => onTurnChange?.(null));
+    };
+    const compactSession = () => {
+        const compacting = (async () => {
+            if (!sessionId) {
+                append({ kind: 'warning', text: 'No active conversation to compact.' });
+                return;
+            }
+            const controller = new AbortController();
+            turnControllerRef.current?.abort();
+            turnControllerRef.current = controller;
+            const compactSignal = signal
+                ? AbortSignal.any([signal, controller.signal])
+                : controller.signal;
+            setBusy(true);
+            setStatus('compacting conversation');
+            setCompactProgress(0);
+            updateMenu({ kind: 'compact-progress' });
+            try {
+                const commands = await service();
+                if (!commands.compact) {
+                    throw new Error('This interactive service cannot compact sessions.');
+                }
+                const result = await commands.compact(sessionId, compactSignal);
+                const projected = await commands.transcript?.(sessionId);
+                setHistory([
+                    ...(projected ?? [{ kind: 'compact', summary: result.summary }]),
+                    { kind: 'user', text: '/compact' },
+                    {
+                        kind: 'local-result',
+                        text: 'Compacted (ctrl+o to see full summary)',
+                    },
+                ]);
+                setUsage((current) => ({
+                    inputTokens: (current?.inputTokens ?? 0) + result.usage.inputTokens,
+                    outputTokens: (current?.outputTokens ?? 0) + result.usage.outputTokens,
+                    cacheReadInputTokens: (current?.cacheReadInputTokens ?? 0) +
+                        (result.usage.cacheReadInputTokens ?? 0),
+                    cacheCreationInputTokens: (current?.cacheCreationInputTokens ?? 0) +
+                        (result.usage.cacheCreationInputTokens ?? 0),
+                }));
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                if (turnControllerRef.current === controller) {
+                    turnControllerRef.current = null;
+                }
+                updateMenu(null);
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(compacting);
+        void compacting.finally(() => onTurnChange?.(null));
+    };
+    const openRewind = () => {
+        const loading = (async () => {
+            if (!sessionId) {
+                append({ kind: 'warning', text: 'No active conversation to rewind.' });
+                return;
+            }
+            setBusy(true);
+            setStatus('loading rewind points');
+            try {
+                const commands = await service();
+                if (!commands.rewindPoints) {
+                    throw new Error('This interactive service cannot inspect rewind points.');
+                }
+                const points = await commands.rewindPoints(sessionId);
+                if (points.length === 0) {
+                    append({
+                        kind: 'warning',
+                        text: 'No conversation checkpoints found.',
+                    });
+                    return;
+                }
+                updateMenu({
+                    kind: 'rewind',
+                    points,
+                    selectedIndex: points.length,
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(loading);
+        void loading.finally(() => onTurnChange?.(null));
+    };
+    const applyRewind = (point, action, summarizationContext) => {
+        if (action === 'cancel') {
+            updateMenu(null);
+            return;
         }
+        const restoring = (async () => {
+            if (!sessionId)
+                return;
+            setBusy(true);
+            setStatus(action.startsWith('summarize') ? 'summarizing' : 'rewinding');
+            try {
+                const commands = await service();
+                if (action === 'summarize-from' || action === 'summarize-to') {
+                    if (!commands.compact) {
+                        throw new Error('This interactive service cannot summarize sessions.');
+                    }
+                    const direction = action === 'summarize-from' ? 'from' : 'to';
+                    const controller = new AbortController();
+                    turnControllerRef.current?.abort();
+                    turnControllerRef.current = controller;
+                    const compactSignal = signal
+                        ? AbortSignal.any([signal, controller.signal])
+                        : controller.signal;
+                    setCompactProgress(0);
+                    updateMenu({ kind: 'compact-progress' });
+                    const result = await commands
+                        .compact(sessionId, compactSignal, {
+                        messageId: point.messageId,
+                        direction,
+                        ...(summarizationContext?.trim()
+                            ? { context: summarizationContext.trim() }
+                            : {}),
+                    })
+                        .finally(() => {
+                        if (turnControllerRef.current === controller) {
+                            turnControllerRef.current = null;
+                        }
+                    });
+                    const projected = await commands.transcript?.(sessionId);
+                    setHistory(projected ?? [{ kind: 'compact', summary: result.summary }]);
+                    if (action === 'summarize-from')
+                        updateComposerInput(point.prompt);
+                    append({ kind: 'assistant', text: 'Summarized conversation' });
+                    append({
+                        kind: 'local-result',
+                        text: `Summarized ${result.messagesSummarized ?? 0} messages ${action === 'summarize-from' ? 'from' : 'up to'} this point\n  (ctrl+o to expand history)`,
+                    });
+                    setUsage((current) => ({
+                        inputTokens: (current?.inputTokens ?? 0) + result.usage.inputTokens,
+                        outputTokens: (current?.outputTokens ?? 0) + result.usage.outputTokens,
+                        cacheReadInputTokens: (current?.cacheReadInputTokens ?? 0) +
+                            (result.usage.cacheReadInputTokens ?? 0),
+                        cacheCreationInputTokens: (current?.cacheCreationInputTokens ?? 0) +
+                            (result.usage.cacheCreationInputTokens ?? 0),
+                    }));
+                    return;
+                }
+                const restoreFiles = action === 'code' || action === 'code-and-conversation';
+                const restoreConversation = action === 'conversation' || action === 'code-and-conversation';
+                let restoredConversation;
+                if (restoreConversation) {
+                    if (point.branchMessageId) {
+                        const originalSessionId = sessionId;
+                        const source = (await commands.sessions()).find((candidate) => candidate.sessionId === originalSessionId);
+                        const fork = await commands.fork(originalSessionId, undefined, point.branchMessageId);
+                        if (source?.name && commands.rename) {
+                            await commands.rename(fork.sessionId, `${source.name} (Branch)`);
+                        }
+                        restoredConversation = {
+                            sessionId: fork.sessionId,
+                            history: (await commands.transcript?.(fork.sessionId)) ?? [],
+                        };
+                    }
+                    else {
+                        restoredConversation = { sessionId: '', history: [] };
+                    }
+                }
+                if (restoreFiles) {
+                    if (!commands.rewindFiles) {
+                        throw new Error('File rewinding is not enabled.');
+                    }
+                    await commands.rewindFiles(sessionId, point.messageId);
+                }
+                if (restoredConversation) {
+                    setSessionId(restoredConversation.sessionId || null);
+                    setPendingFork(false);
+                    setHistory(restoredConversation.history);
+                    updateComposerInput(point.prompt);
+                }
+                append({
+                    kind: 'local-result',
+                    text: action === 'code'
+                        ? 'Code restored. The conversation was unchanged.'
+                        : restoreFiles
+                            ? 'Code and conversation restored. Edit the message and submit to continue.'
+                            : 'Conversation restored. Edit the message and submit to continue.',
+                });
+            }
+            catch (error) {
+                warn(error);
+            }
+            finally {
+                updateMenu(null);
+                setBusy(false);
+                setStatus('ready');
+            }
+        })();
+        onTurnChange?.(restoring);
+        void restoring.finally(() => onTurnChange?.(null));
     };
-    const submit = async (prompt) => {
+    const submit = async (prompt, shellCommand, images = []) => {
+        const turnNumber = turnNumberRef.current + 1;
+        turnNumberRef.current = turnNumber;
+        turnMutatedFilesRef.current = false;
         scheduledWaitRef.current?.abort();
+        appendPromptHistory(prompt);
+        const turnController = new AbortController();
+        turnControllerRef.current?.abort();
+        turnControllerRef.current = turnController;
+        const turnSignal = signal
+            ? AbortSignal.any([signal, turnController.signal])
+            : turnController.signal;
         setBusy(true);
+        setCommandPaletteOpen(false);
         setStatus('assembling-context');
         setActiveText('');
-        append({ kind: 'user', text: prompt });
+        setActiveThinking('');
+        if (shellCommand === undefined)
+            append({ kind: 'user', text: prompt });
+        else
+            turnMutatedFilesRef.current = true;
         let commands;
         try {
             commands = await service();
             let activeSessionId = sessionId;
+            const startedNewSession = activeSessionId === null;
             if (activeSessionId && pendingFork) {
                 const fork = await commands.fork(activeSessionId, resume?.forkSessionId);
                 activeSessionId = fork.sessionId;
                 setSessionId(activeSessionId);
                 setPendingFork(false);
             }
-            const result = activeSessionId
-                ? await commands.resume(activeSessionId, prompt, signal)
-                : await commands.run(prompt, signal);
+            const result = shellCommand === undefined
+                ? activeSessionId
+                    ? await commands.resume(activeSessionId, prompt, turnSignal, undefined, images)
+                    : await commands.run(prompt, turnSignal, undefined, undefined, images)
+                : activeSessionId
+                    ? commands.resumeShell
+                        ? await commands.resumeShell(activeSessionId, shellCommand, turnSignal)
+                        : (() => {
+                            throw new Error('Interactive shell mode is unavailable');
+                        })()
+                    : commands.runShell
+                        ? await commands.runShell(shellCommand, turnSignal)
+                        : (() => {
+                            throw new Error('Interactive shell mode is unavailable');
+                        })();
             setSessionId(result.sessionId);
+            if (startedNewSession &&
+                runtimePreferencesRef.current.permissionMode !== 'default') {
+                try {
+                    await commands.setPermissionMode?.(result.sessionId, runtimePreferencesRef.current.permissionMode);
+                }
+                catch (error) {
+                    warn(error);
+                }
+            }
+            setUsage(result.usage);
+            setCostUsd(result.costUsd);
             append({ kind: 'assistant', text: result.text });
+            if (turnMutatedFilesRef.current) {
+                try {
+                    const snapshot = await loadDiffSnapshot();
+                    setTurnDiffs((current) => [
+                        ...current.filter((source) => source.label !== `T${turnNumber}`),
+                        { label: `T${turnNumber}`, snapshot },
+                    ]);
+                }
+                catch {
+                    // Diff snapshots are a local presentation aid and must not fail a turn.
+                }
+            }
             setActiveText('');
+            setActiveThinking('');
             setStatus('ready');
         }
         catch (error) {
-            append({
-                kind: 'warning',
-                text: redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues),
-            });
-            setStatus('failed');
-        }
-        finally {
+            if (turnController.signal.aborted && !signal?.aborted) {
+                if (shellCommand !== undefined)
+                    updateComposerInput(`!${shellCommand}`);
+                append({ kind: 'notice', text: 'Interrupted by user.' });
+                setStatus('cancelled');
+            }
+            else {
+                append({
+                    kind: 'warning',
+                    text: redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues),
+                });
+                setStatus('failed');
+            }
+        }
+        finally {
             if (!factory.scheduledPrompts && commands) {
                 try {
                     await commands.close?.();
@@ -282,6 +1664,8 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
                         serviceRef.current = null;
                 }
             }
+            if (turnControllerRef.current === turnController)
+                turnControllerRef.current = null;
             setBusy(false);
         }
     };
@@ -338,29 +1722,134 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
         return () => controller.abort();
     }, [busy, initialPromptPending, permission, selectingSession, sessionId]);
     useInput((value, key) => {
-        if (key.ctrl && value.toLowerCase() === 'c') {
-            permissionRef.current?.resolve(false);
-            elicitationRef.current?.resolve({ action: 'cancel' });
-            questionRef.current?.resolve(null);
-            planApprovalRef.current?.resolve(false);
-            onCancel?.();
-            exit();
+        const lower = value.toLowerCase();
+        const controlKey = (letter) => (key.ctrl && lower === letter) ||
+            value === String.fromCharCode(letter.charCodeAt(0) - 96);
+        const printable = [...value].every((character) => {
+            const codePoint = character.codePointAt(0) ?? 0;
+            return codePoint >= 32 && codePoint !== 127;
+        });
+        const editor = () => createComposerEditor(inputRef.current, inputCursorRef.current);
+        const editComposer = () => {
+            if (key.leftArrow) {
+                updateComposerEditor(key.meta
+                    ? moveComposerCursorByWord(editor(), 'backward')
+                    : moveComposerCursorAcrossImages(editor(), -1));
+                return true;
+            }
+            if (key.rightArrow) {
+                updateComposerEditor(key.meta
+                    ? moveComposerCursorByWord(editor(), 'forward')
+                    : moveComposerCursorAcrossImages(editor(), 1));
+                return true;
+            }
+            if (controlKey('a')) {
+                updateComposerEditor(createComposerEditor(inputRef.current, 0));
+                return true;
+            }
+            if (controlKey('e')) {
+                updateComposerEditor(createComposerEditor(inputRef.current));
+                return true;
+            }
+            if (controlKey('b')) {
+                updateComposerEditor(moveComposerCursorAcrossImages(editor(), -1));
+                return true;
+            }
+            if (controlKey('f')) {
+                updateComposerEditor(moveComposerCursorAcrossImages(editor(), 1));
+                return true;
+            }
+            if (controlKey('w')) {
+                updateComposerEditor(deleteComposerWordBackward(editor()));
+                return true;
+            }
+            if (controlKey('u')) {
+                updateComposerEditor(deleteComposerToStart(editor()));
+                return true;
+            }
+            if (controlKey('k')) {
+                updateComposerEditor(deleteComposerToEnd(editor()));
+                return true;
+            }
+            if (key.backspace) {
+                updateComposerEditor(deleteComposerImageBackward(editor()));
+                return true;
+            }
+            if (key.delete) {
+                updateComposerEditor(deleteComposerImageForward(editor()));
+                return true;
+            }
+            if (!key.ctrl && !key.meta && value && printable) {
+                updateComposerEditor(insertComposerText(editor(), value));
+                return true;
+            }
+            return false;
+        };
+        if (controlKey('c')) {
+            armExitConfirmation();
+            return;
+        }
+        if (controlKey('z')) {
+            if (!processSuspendRequestedRef.current) {
+                processSuspendRequestedRef.current = true;
+                setProcessSuspendRequested(true);
+            }
+            return;
+        }
+        dismissExitConfirmation();
+        const keybindingContexts = menuRef.current
+            ? menuRef.current.kind === 'diff'
+                ? ['DiffDialog']
+                : menuRef.current.kind === 'help'
+                    ? ['Help', 'Tabs']
+                    : menuRef.current.kind === 'permission-dashboard'
+                        ? ['Settings', 'Tabs']
+                        : menuRef.current.kind === 'model'
+                            ? ['ModelPicker', 'Select']
+                            : ['Select']
+            : commandPaletteVisible || filePickerVisible
+                ? ['Autocomplete', 'Chat']
+                : permission || planApproval
+                    ? ['Confirmation']
+                    : selectingSession
+                        ? ['Select']
+                        : ['Chat'];
+        const inputChord = tuiKeyChord(value, key);
+        const pendingSequence = keySequenceRef.current;
+        let keybindingAction;
+        if (inputChord &&
+            pendingSequence &&
+            Date.now() - pendingSequence.at <= 1_000) {
+            keybindingAction = resolveTuiKeybinding(keybindings, keybindingContexts, `${pendingSequence.chord} ${inputChord}`);
+            keySequenceRef.current = null;
+        }
+        else {
+            keySequenceRef.current = null;
+        }
+        if (!keybindingAction) {
+            keybindingAction = resolveTuiKeybinding(keybindings, keybindingContexts, inputChord);
+        }
+        if (!keybindingAction &&
+            inputChord &&
+            hasTuiKeybindingPrefix(keybindings, keybindingContexts, inputChord)) {
+            keySequenceRef.current = { chord: inputChord, at: Date.now() };
             return;
         }
+        const isKeybinding = (action) => keybindingAction === action;
         if (permission) {
-            if (value.toLowerCase() === 'y') {
+            if (lower === 'y' || value === '1') {
                 permission.resolve(true);
             }
-            else if (value.toLowerCase() === 'n' || key.return || key.escape) {
+            else if (lower === 'n' || value === '2' || key.return || key.escape) {
                 permission.resolve(false);
             }
             return;
         }
         if (planApproval) {
-            if (value.toLowerCase() === 'y') {
+            if (lower === 'y' || value === '1') {
                 planApproval.resolve(true);
             }
-            else if (value.toLowerCase() === 'n' || key.return || key.escape) {
+            else if (lower === 'n' || value === '2' || key.return || key.escape) {
                 planApproval.resolve(false);
             }
             return;
@@ -376,8 +1865,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
                         throw new Error('Question state is invalid.');
                     const answer = questionAnswer(current, inputRef.current.trim());
                     const answers = { ...question.answers, [current.question]: answer };
-                    inputRef.current = '';
-                    setInput('');
+                    clearComposerInput();
                     if (question.index === question.questions.length - 1) {
                         question.resolve({ answers });
                     }
@@ -394,13 +1882,8 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
                     });
                 }
             }
-            else if (key.backspace || key.delete) {
-                inputRef.current = inputRef.current.slice(0, -1);
-                setInput(inputRef.current);
-            }
-            else if (!key.ctrl && !key.meta && value) {
-                inputRef.current += value;
-                setInput(inputRef.current);
+            else {
+                editComposer();
             }
             return;
         }
@@ -410,8 +1893,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
             }
             else if (key.return) {
                 const answer = inputRef.current.trim();
-                inputRef.current = '';
-                setInput('');
+                clearComposerInput();
                 if (!answer || answer.toLowerCase() === 'decline') {
                     elicitation.resolve({ action: 'decline' });
                 }
@@ -428,10 +1910,9 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
                             typeof content !== 'object' ||
                             Array.isArray(content))
                             throw new Error('elicitation content must be a JSON object');
-                        const elicitationContent = content;
                         elicitation.resolve({
                             action: 'accept',
-                            content: elicitationContent,
+                            content: content,
                         });
                     }
                     catch {
@@ -442,106 +1923,1155 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, signal
                     }
                 }
             }
-            else if (key.backspace || key.delete) {
-                inputRef.current = inputRef.current.slice(0, -1);
-                setInput(inputRef.current);
-            }
-            else if (!key.ctrl && !key.meta && value) {
-                inputRef.current += value;
-                setInput(inputRef.current);
+            else {
+                editComposer();
             }
             return;
         }
         if (selectingSession) {
-            if (key.upArrow) {
+            if (key.escape || value === '\u001B') {
+                if (pickerIncludesNewSessionRef.current && allowNewSession) {
+                    setSessionId(null);
+                    setPendingFork(false);
+                    setSelectingSession(false);
+                }
+                else if (allowNewSession) {
+                    setSelectingSession(false);
+                }
+                else {
+                    onCancel?.();
+                    exit();
+                }
+            }
+            else if (key.upArrow) {
                 selectedIndexRef.current = Math.max(0, selectedIndexRef.current - 1);
                 setSelectedIndex(selectedIndexRef.current);
             }
             else if (key.downArrow) {
-                selectedIndexRef.current = Math.min(choices.length - 1, selectedIndexRef.current + 1);
+                selectedIndexRef.current = Math.min(Math.max(0, filteredPickerChoices.length - 1), selectedIndexRef.current + 1);
                 setSelectedIndex(selectedIndexRef.current);
             }
             else if (key.return) {
-                const selected = choices[selectedIndexRef.current];
-                setSessionId(selected?.sessionId ?? null);
+                const currentPickerChoices = pickerIncludesNewSessionRef.current
+                    ? choices
+                    : initialSessions;
+                const selected = filterSessionChoices(currentPickerChoices, sessionSearchRef.current)[selectedIndexRef.current];
+                if (selected === undefined)
+                    return;
+                openSession(selected?.sessionId ?? null);
                 if (!selected)
                     setPendingFork(false);
                 setSelectingSession(false);
             }
+            else if (key.backspace || key.delete) {
+                sessionSearchRef.current = sessionSearchRef.current.slice(0, -1);
+                setSessionSearch(sessionSearchRef.current);
+                selectedIndexRef.current = 0;
+                setSelectedIndex(0);
+            }
+            else if (!key.ctrl && !key.meta && value && printable) {
+                sessionSearchRef.current += value;
+                setSessionSearch(sessionSearchRef.current);
+                selectedIndexRef.current = 0;
+                setSelectedIndex(0);
+            }
+            return;
+        }
+        if (externalEditorRequest !== null || keybindingsEditing)
+            return;
+        if (clipboardPendingRef.current > 0) {
+            if (isKeybinding('chat:imagePaste'))
+                pasteClipboard();
+            return;
+        }
+        if (!busy &&
+            !permission &&
+            !planApproval &&
+            !question &&
+            !elicitation &&
+            !menuRef.current &&
+            isKeybinding('chat:externalEditor')) {
+            setCommandPaletteOpen(false);
+            setFilePickerOpen(false);
+            setShortcutsVisible(false);
+            setExternalEditorRequest({ prompt: inputRef.current });
+            return;
+        }
+        if (!busy && isKeybinding('app:toggleTodos')) {
+            openTasks();
+            return;
+        }
+        if (!busy && isKeybinding('chat:modelPicker')) {
+            updateMenu({ kind: 'model', selectedIndex: 0 });
             return;
         }
-        if (busy)
+        if (!busy && isKeybinding('chat:stash')) {
+            if (inputRef.current.length > 0) {
+                stashedInputRef.current = inputRef.current;
+                clearComposerInput();
+            }
+            else if (stashedInputRef.current.length > 0) {
+                const stashed = stashedInputRef.current;
+                stashedInputRef.current = '';
+                updateComposerInput(stashed);
+            }
             return;
-        if (key.return) {
+        }
+        const activeMenu = menuRef.current;
+        if (activeMenu) {
+            if (activeMenu.kind === 'help') {
+                if (key.escape) {
+                    updateMenu(null);
+                    return;
+                }
+                if (key.leftArrow || key.rightArrow) {
+                    updateMenu({
+                        kind: 'help',
+                        tabIndex: Math.max(0, Math.min(2, activeMenu.tabIndex + (key.leftArrow ? -1 : 1))),
+                        selectedIndex: 0,
+                    });
+                    return;
+                }
+                const commands = activeMenu.tabIndex === 1
+                    ? builtinSlashCommands
+                    : activeMenu.tabIndex === 2
+                        ? customSlashCommands
+                        : [];
+                if (key.upArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(0, activeMenu.selectedIndex - 1),
+                    });
+                }
+                else if (key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.min(Math.max(0, commands.length - 1), activeMenu.selectedIndex + 1),
+                    });
+                }
+                return;
+            }
+            if (activeMenu.kind === 'diff') {
+                const snapshot = activeMenu.snapshots[activeMenu.sourceIndex]?.snapshot;
+                const selectedFile = snapshot?.files[activeMenu.selectedIndex];
+                if (key.escape || value === '\u001B') {
+                    updateMenu(activeMenu.viewingFile
+                        ? { ...activeMenu, viewingFile: false, scrollOffset: 0 }
+                        : null);
+                    return;
+                }
+                if (key.leftArrow || key.rightArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        sourceIndex: Math.max(0, Math.min(activeMenu.snapshots.length - 1, activeMenu.sourceIndex + (key.leftArrow ? -1 : 1))),
+                        selectedIndex: 0,
+                        viewingFile: false,
+                        scrollOffset: 0,
+                    });
+                    return;
+                }
+                if (activeMenu.viewingFile) {
+                    const maxOffset = Math.max(0, visiblePatchLines(selectedFile?.patch ?? '').length - 18);
+                    if (key.upArrow || key.downArrow) {
+                        updateMenu({
+                            ...activeMenu,
+                            scrollOffset: Math.max(0, Math.min(maxOffset, activeMenu.scrollOffset + (key.upArrow ? -1 : 1))),
+                        });
+                    }
+                    return;
+                }
+                if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(0, Math.min(Math.max(0, (snapshot?.files.length ?? 0) - 1), activeMenu.selectedIndex + (key.upArrow ? -1 : 1))),
+                    });
+                }
+                else if (key.return && selectedFile) {
+                    updateMenu({ ...activeMenu, viewingFile: true, scrollOffset: 0 });
+                }
+                return;
+            }
+            if (activeMenu.kind === 'permission-rule-input') {
+                if (key.escape || value === '\u001B') {
+                    clearComposerInput();
+                    updateMenu({
+                        kind: 'permission-dashboard',
+                        tabIndex: 1,
+                        selectedIndex: -1,
+                        query: '',
+                        rules: activeMenu.rules,
+                    });
+                }
+                else if (key.return) {
+                    const rule = inputRef.current.trim();
+                    if (!rule) {
+                        append({
+                            kind: 'warning',
+                            text: 'Enter a permission rule or press Esc.',
+                        });
+                    }
+                    else {
+                        clearComposerInput();
+                        updateMenu({
+                            kind: 'permission-scope',
+                            behavior: activeMenu.behavior,
+                            rule,
+                            rules: activeMenu.rules,
+                            selectedIndex: 0,
+                        });
+                    }
+                }
+                else {
+                    editComposer();
+                }
+                return;
+            }
+            if (activeMenu.kind === 'workspace-directory-input') {
+                if (key.escape || value === '\u001B') {
+                    clearComposerInput();
+                    if (activeMenu.returnToPermissions === false) {
+                        updateMenu(null);
+                        append({
+                            kind: 'local-result',
+                            text: 'Did not add a working directory.',
+                        });
+                    }
+                    else {
+                        updateMenu({
+                            kind: 'permission-dashboard',
+                            tabIndex: 1,
+                            selectedIndex: -1,
+                            query: '',
+                            rules: activeMenu.rules,
+                        });
+                    }
+                }
+                else if (key.tab) {
+                    const completion = (async () => {
+                        try {
+                            updateComposerInput(await workspaceDirectoryCompleter(inputRef.current, runtimeCwdRef.current));
+                        }
+                        catch (error) {
+                            warn(error);
+                        }
+                    })();
+                    onTurnChange?.(completion);
+                    void completion.finally(() => onTurnChange?.(null));
+                }
+                else if (key.return) {
+                    const addition = (async () => {
+                        setBusy(true);
+                        try {
+                            const path = await workspaceDirectoryResolver(inputRef.current, runtimeCwdRef.current);
+                            clearComposerInput();
+                            if (path !== runtimeCwdRef.current) {
+                                updateRuntimePreferences((current) => ({
+                                    ...current,
+                                    additionalDirectories: [
+                                        ...new Set([...current.additionalDirectories, path]),
+                                    ],
+                                }));
+                                await retireService();
+                            }
+                            const rules = await permissionStore.load();
+                            if (activeMenu.returnToPermissions === false) {
+                                updateMenu(null);
+                                append({
+                                    kind: 'local-result',
+                                    text: `Added ${path} as a working directory.`,
+                                });
+                            }
+                            else {
+                                updateMenu({
+                                    kind: 'permission-dashboard',
+                                    tabIndex: 1,
+                                    selectedIndex: -1,
+                                    query: '',
+                                    rules,
+                                });
+                            }
+                        }
+                        catch (error) {
+                            warn(error);
+                        }
+                        finally {
+                            setBusy(false);
+                        }
+                    })();
+                    onTurnChange?.(addition);
+                    void addition.finally(() => onTurnChange?.(null));
+                }
+                else {
+                    editComposer();
+                }
+                return;
+            }
+            if (activeMenu.kind === 'workspace-directory-delete') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu({
+                        kind: 'permission-dashboard',
+                        tabIndex: 1,
+                        selectedIndex: -1,
+                        query: '',
+                        rules: activeMenu.rules,
+                    });
+                    return;
+                }
+                if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: key.upArrow ? 0 : 1,
+                    });
+                    return;
+                }
+                const confirmed = (key.return && activeMenu.selectedIndex === 0) ||
+                    value.toLowerCase() === 'y' ||
+                    value === '1';
+                const declined = (key.return && activeMenu.selectedIndex === 1) ||
+                    value.toLowerCase() === 'n' ||
+                    value === '2';
+                if (!confirmed && !declined)
+                    return;
+                if (confirmed) {
+                    updateRuntimePreferences((current) => ({
+                        ...current,
+                        additionalDirectories: current.additionalDirectories.filter((path) => path !== activeMenu.path),
+                    }));
+                    void retireService();
+                }
+                updateMenu({
+                    kind: 'permission-dashboard',
+                    tabIndex: 1,
+                    selectedIndex: -1,
+                    query: '',
+                    rules: activeMenu.rules,
+                });
+                return;
+            }
+            if (activeMenu.kind === 'permission-delete') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu({
+                        kind: 'permission-dashboard',
+                        tabIndex: 1,
+                        selectedIndex: -1,
+                        query: '',
+                        rules: activeMenu.rules,
+                    });
+                    return;
+                }
+                if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: key.upArrow ? 0 : 1,
+                    });
+                    return;
+                }
+                const confirmed = (key.return && activeMenu.selectedIndex === 0) ||
+                    value.toLowerCase() === 'y' ||
+                    value === '1';
+                const declined = (key.return && activeMenu.selectedIndex === 1) ||
+                    value.toLowerCase() === 'n' ||
+                    value === '2';
+                if (!confirmed && !declined)
+                    return;
+                if (declined) {
+                    updateMenu({
+                        kind: 'permission-dashboard',
+                        tabIndex: 1,
+                        selectedIndex: -1,
+                        query: '',
+                        rules: activeMenu.rules,
+                    });
+                    return;
+                }
+                const removal = (async () => {
+                    setBusy(true);
+                    try {
+                        if (!permissionStore.remove)
+                            throw new Error('Permission rule removal is unavailable.');
+                        await permissionStore.remove(activeMenu.rule);
+                        await retireService();
+                        const rules = await permissionStore.load();
+                        updateMenu({
+                            kind: 'permission-dashboard',
+                            tabIndex: 1,
+                            selectedIndex: -1,
+                            query: '',
+                            rules,
+                        });
+                    }
+                    catch (error) {
+                        warn(error);
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                })();
+                onTurnChange?.(removal);
+                void removal.finally(() => onTurnChange?.(null));
+                return;
+            }
+            if (activeMenu.kind === 'permission-scope') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu({
+                        kind: 'permission-dashboard',
+                        tabIndex: 1,
+                        selectedIndex: -1,
+                        query: '',
+                        rules: activeMenu.rules,
+                    });
+                    return;
+                }
+                if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(0, Math.min(2, activeMenu.selectedIndex + (key.upArrow ? -1 : 1))),
+                    });
+                    return;
+                }
+                if (key.return) {
+                    const scopes = ['local', 'project', 'user'];
+                    const scope = scopes[activeMenu.selectedIndex];
+                    if (!scope)
+                        return;
+                    const addition = (async () => {
+                        setBusy(true);
+                        try {
+                            await permissionStore.add({
+                                behavior: activeMenu.behavior,
+                                rule: activeMenu.rule,
+                                scope,
+                            });
+                            await retireService();
+                            const rules = await permissionStore.load();
+                            updateMenu({
+                                kind: 'permission-dashboard',
+                                tabIndex: 1,
+                                selectedIndex: -1,
+                                query: '',
+                                rules,
+                            });
+                        }
+                        catch (error) {
+                            warn(error);
+                        }
+                        finally {
+                            setBusy(false);
+                        }
+                    })();
+                    onTurnChange?.(addition);
+                    void addition.finally(() => onTurnChange?.(null));
+                }
+                return;
+            }
+            if (activeMenu.kind === 'permission-dashboard') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu(null);
+                    return;
+                }
+                if (key.leftArrow || key.rightArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        tabIndex: Math.max(0, Math.min(4, activeMenu.tabIndex + (key.leftArrow ? -1 : 1))),
+                        selectedIndex: -1,
+                        query: '',
+                    });
+                    return;
+                }
+                const behavior = ['allow', 'ask', 'deny'][activeMenu.tabIndex - 1];
+                const query = activeMenu.query.toLowerCase();
+                const matchingRules = behavior
+                    ? activeMenu.rules.filter((rule) => rule.behavior === behavior &&
+                        (!query ||
+                            rule.rule.toLowerCase().includes(query) ||
+                            rule.scope.includes(query)))
+                    : [];
+                const rowCount = activeMenu.tabIndex === 0
+                    ? recentDenied.length
+                    : activeMenu.tabIndex === 4
+                        ? runtimePreferences.additionalDirectories.length + 1
+                        : matchingRules.length + 1;
+                if (key.upArrow || key.downArrow) {
+                    if (rowCount === 0)
+                        return;
+                    const nextIndex = activeMenu.selectedIndex < 0
+                        ? key.downArrow
+                            ? 0
+                            : -1
+                        : activeMenu.selectedIndex + (key.upArrow ? -1 : 1);
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(-1, Math.min(Math.max(0, rowCount - 1), nextIndex)),
+                    });
+                }
+                else if (key.backspace || key.delete) {
+                    updateMenu({
+                        ...activeMenu,
+                        query: activeMenu.query.slice(0, -1),
+                        selectedIndex: -1,
+                    });
+                }
+                else if (behavior && !key.ctrl && !key.meta && value && printable) {
+                    updateMenu({
+                        ...activeMenu,
+                        query: activeMenu.query + value,
+                        selectedIndex: -1,
+                    });
+                }
+                else if (key.return && behavior && activeMenu.selectedIndex === 0) {
+                    clearComposerInput();
+                    updateMenu({
+                        kind: 'permission-rule-input',
+                        behavior,
+                        rules: activeMenu.rules,
+                    });
+                }
+                else if (key.return && behavior && activeMenu.selectedIndex > 0) {
+                    const rule = matchingRules[activeMenu.selectedIndex - 1];
+                    if (rule)
+                        updateMenu({
+                            kind: 'permission-delete',
+                            rule,
+                            rules: activeMenu.rules,
+                            selectedIndex: 0,
+                        });
+                }
+                else if (key.return &&
+                    activeMenu.tabIndex === 4 &&
+                    activeMenu.selectedIndex >= 0) {
+                    const path = runtimePreferences.additionalDirectories[activeMenu.selectedIndex];
+                    if (path) {
+                        updateMenu({
+                            kind: 'workspace-directory-delete',
+                            path,
+                            rules: activeMenu.rules,
+                            selectedIndex: 0,
+                        });
+                    }
+                    else if (activeMenu.selectedIndex ===
+                        runtimePreferences.additionalDirectories.length) {
+                        clearComposerInput();
+                        updateMenu({
+                            kind: 'workspace-directory-input',
+                            rules: activeMenu.rules,
+                        });
+                    }
+                }
+                return;
+            }
+            if (activeMenu.kind === 'status') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu(null);
+                }
+                else if (key.leftArrow || key.rightArrow || key.tab) {
+                    const direction = key.leftArrow || (key.tab && key.shift) ? -1 : 1;
+                    updateMenu({
+                        kind: 'status',
+                        tabIndex: Math.max(0, Math.min(4, activeMenu.tabIndex + direction)),
+                    });
+                }
+                return;
+            }
+            if (activeMenu.kind === 'list') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu(null);
+                }
+                else if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(0, Math.min(Math.max(0, activeMenu.rows.length - 1), activeMenu.selectedIndex + (key.upArrow ? -1 : 1))),
+                    });
+                }
+                return;
+            }
+            if (activeMenu.kind === 'rewind') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu(null);
+                }
+                else if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(0, Math.min(activeMenu.points.length, activeMenu.selectedIndex + (key.upArrow ? -1 : 1))),
+                    });
+                }
+                else if (key.return) {
+                    const point = activeMenu.points[activeMenu.selectedIndex];
+                    if (!point) {
+                        updateMenu(null);
+                    }
+                    else {
+                        updateMenu({
+                            kind: 'rewind-confirm',
+                            points: activeMenu.points,
+                            point,
+                            selectedIndex: 0,
+                        });
+                    }
+                }
+                return;
+            }
+            if (activeMenu.kind === 'rewind-confirm') {
+                const actions = rewindActions(activeMenu.point);
+                if (key.escape || value === '\u001B') {
+                    updateMenu({
+                        kind: 'rewind',
+                        points: activeMenu.points,
+                        selectedIndex: Math.max(0, activeMenu.points.findIndex((point) => point.messageId === activeMenu.point.messageId)),
+                    });
+                }
+                else if (key.upArrow || key.downArrow) {
+                    updateMenu({
+                        ...activeMenu,
+                        selectedIndex: Math.max(0, Math.min(actions.length - 1, activeMenu.selectedIndex + (key.upArrow ? -1 : 1))),
+                    });
+                }
+                else if (key.return) {
+                    const selected = actions[activeMenu.selectedIndex];
+                    if (selected?.action === 'summarize-from' ||
+                        selected?.action === 'summarize-to') {
+                        clearComposerInput();
+                        updateMenu({
+                            kind: 'rewind-context',
+                            points: activeMenu.points,
+                            point: activeMenu.point,
+                            direction: selected.action === 'summarize-from' ? 'from' : 'to',
+                        });
+                    }
+                    else if (selected) {
+                        applyRewind(activeMenu.point, selected.action);
+                    }
+                }
+                return;
+            }
+            if (activeMenu.kind === 'rewind-context') {
+                if (key.escape || value === '\u001B') {
+                    clearComposerInput();
+                    updateMenu({
+                        kind: 'rewind-confirm',
+                        points: activeMenu.points,
+                        point: activeMenu.point,
+                        selectedIndex: activeMenu.direction === 'from'
+                            ? rewindActions(activeMenu.point).findIndex((option) => option.action === 'summarize-from')
+                            : rewindActions(activeMenu.point).findIndex((option) => option.action === 'summarize-to'),
+                    });
+                }
+                else if (key.return) {
+                    const context = inputRef.current;
+                    clearComposerInput();
+                    applyRewind(activeMenu.point, activeMenu.direction === 'from' ? 'summarize-from' : 'summarize-to', context);
+                }
+                else {
+                    editComposer();
+                }
+                return;
+            }
+            if (activeMenu.kind === 'model-input') {
+                if (key.escape) {
+                    clearComposerInput();
+                    updateMenu(null);
+                }
+                else if (key.return) {
+                    const model = inputRef.current.trim();
+                    if (!model) {
+                        append({ kind: 'warning', text: 'Enter a model ID or press Esc.' });
+                    }
+                    else {
+                        clearComposerInput();
+                        updateMenu(null);
+                        changeModel(model);
+                    }
+                }
+                else {
+                    editComposer();
+                }
+                return;
+            }
+            if (activeMenu.kind === 'export-filename') {
+                if (key.escape || value === '\u001B') {
+                    clearComposerInput();
+                    updateMenu({ kind: 'export', selectedIndex: 1 });
+                }
+                else if (key.return) {
+                    const filename = inputRef.current.trim();
+                    if (!filename) {
+                        append({ kind: 'warning', text: 'Enter a filename or press Esc.' });
+                    }
+                    else {
+                        saveConversation(filename);
+                    }
+                }
+                else {
+                    editComposer();
+                }
+                return;
+            }
+            if (activeMenu.kind === 'export') {
+                if (key.escape || value === '\u001B') {
+                    updateMenu(null);
+                }
+                else if (key.upArrow || key.downArrow) {
+                    updateMenu({ ...activeMenu, selectedIndex: key.upArrow ? 0 : 1 });
+                }
+                else if (value === '1' || value === '2') {
+                    updateMenu({ ...activeMenu, selectedIndex: Number(value) - 1 });
+                }
+                else if (key.return) {
+                    exportConversation(activeMenu.selectedIndex === 0 ? 'clipboard' : 'file');
+                }
+                return;
+            }
+            if (activeMenu.kind === 'compact-progress') {
+                if (key.escape || value === '\u001B' || isKeybinding('chat:cancel')) {
+                    turnControllerRef.current?.abort();
+                }
+                return;
+            }
+            if (key.escape) {
+                updateMenu(null);
+                return;
+            }
+            const optionCount = activeMenu.kind === 'model'
+                ? modelOptions.length
+                : EFFORT_OPTIONS.length;
+            const select = (selectedIndex) => updateMenu({ ...activeMenu, selectedIndex });
+            if (key.upArrow) {
+                select(Math.max(0, activeMenu.selectedIndex - 1));
+                return;
+            }
+            if (key.downArrow) {
+                select(Math.min(optionCount - 1, activeMenu.selectedIndex + 1));
+                return;
+            }
+            if (/^[1-9]$/u.test(value)) {
+                select(Math.min(optionCount - 1, Number(value) - 1));
+                return;
+            }
+            if (activeMenu.kind === 'model' && (key.leftArrow || key.rightArrow)) {
+                const currentEffort = runtimePreferencesRef.current.effort;
+                const currentIndex = EFFORT_OPTIONS.indexOf(currentEffort);
+                const nextIndex = Math.max(0, Math.min(EFFORT_OPTIONS.length - 1, currentIndex + (key.leftArrow ? -1 : 1)));
+                const nextEffort = EFFORT_OPTIONS[nextIndex];
+                if (nextEffort && nextEffort !== currentEffort)
+                    changeEffort(nextEffort);
+                return;
+            }
+            if (!key.return && lower !== 's')
+                return;
+            if (activeMenu.kind === 'model') {
+                if (activeMenu.selectedIndex === 1) {
+                    updateMenu(null);
+                    changeModel(undefined);
+                }
+                else if (activeMenu.selectedIndex === 2) {
+                    clearComposerInput();
+                    updateMenu({ kind: 'model-input' });
+                }
+                else {
+                    updateMenu(null);
+                }
+            }
+            else {
+                const selectedEffort = EFFORT_OPTIONS[activeMenu.selectedIndex];
+                if (selectedEffort)
+                    changeEffort(selectedEffort);
+                updateMenu(null);
+            }
+            return;
+        }
+        if (!busy && value === '?' && inputRef.current.length === 0) {
+            setShortcutsVisible((current) => !current);
+            return;
+        }
+        if (isKeybinding('app:toggleTranscript') && hasDetailedTranscript) {
+            setThinkingExpanded((current) => !current);
+            return;
+        }
+        if (busy) {
+            if (isKeybinding('chat:cancel'))
+                turnControllerRef.current?.abort();
+            return;
+        }
+        if (isKeybinding('chat:imagePaste')) {
+            pasteClipboard();
+            return;
+        }
+        if (isKeybinding('chat:undo')) {
+            const previous = undoStackRef.current.at(-1);
+            if (previous) {
+                undoStackRef.current = undoStackRef.current.slice(0, -1);
+                updateComposerEditor(previous, false);
+            }
+            return;
+        }
+        if (filePickerVisible) {
+            if (key.escape || value === '\u001B') {
+                setFilePickerOpen(false);
+                return;
+            }
+            if (key.upArrow) {
+                setFileSelection((current) => Math.max(0, current - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setFileSelection((current) => Math.min(matchingMentionEntries.length - 1, current + 1));
+                return;
+            }
+            const selected = matchingMentionEntries[selectedFileIndex];
+            if (selected && (key.tab || key.return) && fileReference) {
+                updateComposerEditor(applyMentionReference(inputRef.current, inputCursorRef.current, fileReference, selected));
+                setFilePickerOpen(false);
+                return;
+            }
+            if (key.tab)
+                return;
+        }
+        if (isKeybinding('chat:cancel')) {
+            const now = Date.now();
+            if (now - lastEscapeAtRef.current <= 500)
+                clearComposerInput();
+            lastEscapeAtRef.current = now;
+            return;
+        }
+        if (isKeybinding('chat:cycleMode')) {
+            const currentIndex = permissionOptions.findIndex((option) => option.mode === runtimePreferences.permissionMode);
+            const next = permissionOptions[(currentIndex + 1) % permissionOptions.length];
+            if (next)
+                changePermissionMode(next.mode);
+            return;
+        }
+        if (commandPaletteVisible) {
+            if (key.escape) {
+                setCommandPaletteOpen(false);
+                return;
+            }
+            if (key.upArrow) {
+                if (matchingSlashCommands.length > 0) {
+                    setCommandSelection((current) => Math.max(0, current - 1));
+                }
+                return;
+            }
+            if (key.downArrow) {
+                if (matchingSlashCommands.length > 0) {
+                    setCommandSelection((current) => Math.min(matchingSlashCommands.length - 1, current + 1));
+                }
+                return;
+            }
+            const selectedCommand = matchingSlashCommands[selectedSlashCommandIndex];
+            const exactSelectedCommand = selectedCommand !== undefined &&
+                inputRef.current.toLocaleLowerCase() ===
+                    `/${selectedCommand.name}`.toLocaleLowerCase();
+            if (selectedCommand &&
+                (key.tab || (key.return && !exactSelectedCommand))) {
+                updateComposerInput(`/${selectedCommand.name} `);
+                setCommandPaletteOpen(false);
+                return;
+            }
+        }
+        const implicitShiftNewline = key.return && key.shift && keybindingAction === undefined;
+        if (isKeybinding('chat:submit') ||
+            isKeybinding('chat:newline') ||
+            implicitShiftNewline) {
+            if (isKeybinding('chat:newline') || implicitShiftNewline) {
+                updateComposerEditor(insertComposerText(editor(), '\n'));
+                return;
+            }
+            if (inputRef.current.endsWith('\\')) {
+                const withoutContinuation = createComposerEditor(inputRef.current.slice(0, -1));
+                updateComposerEditor(insertComposerText(withoutContinuation, '\n'));
+                return;
+            }
             const prompt = inputRef.current.trim();
-            inputRef.current = '';
-            setInput('');
-            if (!prompt)
+            const images = promptImages(prompt);
+            clearComposerInput();
+            undoStackRef.current = [];
+            composerImagesRef.current.clear();
+            if (!prompt || prompt === '!')
                 return;
+            const copyCommand = /^\/copy(?:\s+(\d+))?$/u.exec(prompt);
+            const renameCommand = /^\/rename(?:\s+(.+))?$/u.exec(prompt);
+            const cdCommand = /^\/cd(?:\s+(.+))?$/u.exec(prompt);
             if (prompt === '/exit') {
                 exit();
             }
+            else if (prompt === '/help' || prompt === '?') {
+                updateMenu({ kind: 'help', tabIndex: 0, selectedIndex: 0 });
+            }
             else if (prompt === '/new') {
                 setSessionId(null);
                 setPendingFork(false);
                 append({ kind: 'notice', text: 'Started a new session.' });
             }
-            else if (prompt === '/sessions') {
+            else if (prompt === '/clear') {
+                setSessionId(null);
+                setPendingFork(false);
+                setHistory([]);
+                setUsage(undefined);
+                setCostUsd(undefined);
+                setActiveText('');
+                setActiveThinking('');
+                setThinkingExpanded(false);
+                setStatus('ready');
+                inputHistoryRef.current = [];
+                inputHistoryIndexRef.current = null;
+                inputHistoryDraftRef.current = '';
+            }
+            else if (prompt === '/model') {
+                updateMenu({ kind: 'model', selectedIndex: 0 });
+            }
+            else if (prompt === '/effort') {
+                updateMenu({
+                    kind: 'effort',
+                    selectedIndex: EFFORT_OPTIONS.indexOf(runtimePreferences.effort),
+                });
+            }
+            else if (prompt === '/keybindings') {
+                setKeybindingsEditing(true);
+            }
+            else if (prompt === '/add-dir') {
+                openWorkspaceDirectoryInput();
+            }
+            else if (cdCommand) {
+                append({ kind: 'user', text: prompt });
+                const requestedCwd = cdCommand[1]?.trim();
+                if (!requestedCwd) {
+                    showCdUsage();
+                }
+                else {
+                    changeWorkingDirectory(requestedCwd);
+                }
+            }
+            else if (prompt === '/branch') {
+                append({ kind: 'user', text: prompt });
+                branchSession();
+            }
+            else if (prompt === '/compact') {
+                compactSession();
+            }
+            else if (prompt === '/rewind') {
+                openRewind();
+            }
+            else if (prompt === '/export') {
+                append({ kind: 'user', text: prompt });
+                updateMenu({ kind: 'export', selectedIndex: 0 });
+            }
+            else if (prompt === '/permissions') {
+                const loading = (async () => {
+                    setBusy(true);
+                    try {
+                        updateMenu({
+                            kind: 'permission-dashboard',
+                            tabIndex: 1,
+                            selectedIndex: -1,
+                            query: '',
+                            rules: await permissionStore.load(),
+                        });
+                    }
+                    catch (error) {
+                        warn(error);
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                })();
+                onTurnChange?.(loading);
+                void loading.finally(() => onTurnChange?.(null));
+            }
+            else if (prompt === '/resume' || prompt === '/sessions') {
+                pickerIncludesNewSessionRef.current = false;
+                setPickerIncludesNewSession(false);
+                sessionSearchRef.current = '';
+                setSessionSearch('');
                 selectedIndexRef.current = 0;
                 setSelectedIndex(0);
                 setSelectingSession(true);
             }
-            else if (prompt === '/workflows') {
-                const turn = (async () => {
+            else if (prompt === '/diff') {
+                const inspection = (async () => {
                     setBusy(true);
+                    setStatus('loading diff');
                     try {
-                        const workflows = (await service()).workflows?.() ?? [];
-                        append({
-                            kind: 'notice',
-                            text: workflows.length === 0
-                                ? 'No workflows.'
-                                : workflows
-                                    .map((workflow) => `${String(workflow.task_id)} [${String(workflow.status)}] ${String(workflow.summary)}`)
-                                    .join('\n'),
+                        const current = await loadDiffSnapshot();
+                        updateMenu({
+                            kind: 'diff',
+                            snapshots: [
+                                { label: 'Current', snapshot: current },
+                                ...turnDiffs,
+                            ],
+                            sourceIndex: 0,
+                            selectedIndex: 0,
+                            viewingFile: false,
+                            scrollOffset: 0,
                         });
                     }
                     catch (error) {
-                        append({
-                            kind: 'warning',
-                            text: redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues),
-                        });
+                        warn(error);
                     }
                     finally {
                         setBusy(false);
+                        setStatus('ready');
                     }
                 })();
+                onTurnChange?.(inspection);
+                void inspection.finally(() => onTurnChange?.(null));
+            }
+            else if (prompt === '/context') {
+                const skills = allSlashCommands
+                    .filter((command) => command.source === 'skill')
+                    .map((command) => ({
+                    name: command.name,
+                    tokens: estimatedCommandTokens(command),
+                }));
+                const measuredTokens = (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0);
+                const skillTokens = skills.reduce((total, skill) => total + skill.tokens, 0);
+                setHistory((current) => [
+                    ...current,
+                    { kind: 'user', text: '/context' },
+                    {
+                        kind: 'context',
+                        usedTokens: Math.max(measuredTokens, skillTokens),
+                        contextWindowTokens: runtimeDisplay.contextWindowTokens ?? 200_000,
+                        skills,
+                    },
+                ]);
+            }
+            else if (prompt === '/status') {
+                updateMenu({ kind: 'status', tabIndex: 1 });
+            }
+            else if (prompt === '/config') {
+                updateMenu({ kind: 'status', tabIndex: 2 });
+            }
+            else if (prompt === '/usage') {
+                updateMenu({ kind: 'status', tabIndex: 3 });
+            }
+            else if (prompt === '/skills' || prompt === '/skill') {
+                updateMenu({
+                    kind: 'list',
+                    title: 'Skills',
+                    rows: allSlashCommands
+                        .filter((command) => command.source === 'skill')
+                        .map((command) => ({
+                        label: command.name,
+                        description: command.description,
+                    })),
+                    emptyText: 'No skills found\nCreate skills in .claude/skills/ or ~/.claude/skills/',
+                    selectedIndex: 0,
+                });
+            }
+            else if (prompt === '/tasks' || prompt === '/workflows') {
+                openTasks();
+            }
+            else if (prompt === '/mcp') {
+                openMcpServers();
+            }
+            else if (prompt === '/reload-plugins') {
+                reloadExtensions('plugins');
+            }
+            else if (prompt === '/reload-skills') {
+                reloadExtensions('skills');
+            }
+            else if (copyCommand) {
+                append({ kind: 'user', text: prompt });
+                const ordinal = Number(copyCommand[1] ?? 1);
+                if (!Number.isSafeInteger(ordinal) || ordinal < 1) {
+                    append({ kind: 'warning', text: 'Usage: /copy [positive number]' });
+                }
+                else {
+                    copyResponse(ordinal);
+                }
+            }
+            else if (renameCommand) {
+                append({ kind: 'user', text: prompt });
+                renameSession(renameCommand[1]);
+            }
+            else if (prompt === '/plan') {
+                changePermissionMode('plan');
+            }
+            else if (prompt.startsWith('!')) {
+                const command = prompt.slice(1).trim();
+                const turn = submit(`! ${command}`, command);
                 onTurnChange?.(turn);
-                void turn.finally(() => onTurnChange?.(null));
+                void turn.then(() => onTurnChange?.(null), () => onTurnChange?.(null));
             }
             else {
-                const turn = submit(prompt);
+                const turn = submit(prompt, undefined, images);
                 onTurnChange?.(turn);
                 void turn.then(() => onTurnChange?.(null), () => onTurnChange?.(null));
             }
+            return;
+        }
+        if (isKeybinding('history:previous')) {
+            restorePromptHistory('previous');
+            return;
         }
-        else if (key.backspace || key.delete) {
-            inputRef.current = inputRef.current.slice(0, -1);
-            setInput(inputRef.current);
+        if (isKeybinding('history:next')) {
+            restorePromptHistory('next');
+            return;
         }
-        else if (!key.ctrl && !key.meta && value) {
-            inputRef.current += value;
-            setInput(inputRef.current);
+        if (isKeybinding('chat:clearInput')) {
+            clearComposerInput();
+            return;
         }
+        editComposer();
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [axScreenReader ? null : (_jsx(Text, { bold: true, color: "cyan", children: "Praxis" })), selectingSession ? (_jsxs(Box, { flexDirection: "column", children: [axScreenReader ? null : (_jsx(Text, { dimColor: true, children: "Select session \u00B7 \u2191/\u2193 move \u00B7 Enter confirm" })), choices.map((session, index) => (_jsxs(Text, { children: [index === selectedIndex ? '› ' : '  ', session
-                                ? `${session.name ?? session.lastPrompt ?? 'Untitled'} · ${session.sessionId}${session.status === 'ready' ? '' : ` · ${session.status}`}`
-                                : 'New session'] }, session?.sessionId ?? 'new')))] })) : (_jsxs(_Fragment, { children: [sessionId ? _jsxs(Text, { dimColor: true, children: ["Session ", sessionId] }) : null, history.map((line, index) => (_jsxs(Text, { ...(line.kind === 'warning' ? { color: 'red' } : {}), children: [line.kind === 'user'
-                                ? 'You: '
-                                : line.kind === 'assistant'
-                                    ? 'Praxis: '
-                                    : '· ', line.text] }, `${index}-${line.kind}`))), activeText ? _jsxs(Text, { children: ["Praxis: ", activeText] }) : null, permission ? (_jsxs(Text, { color: "yellow", children: [permission.kind === 'recovery' ? 'Retry interrupted ' : 'Allow ', describeTool(permission.call, sensitiveValues), "? (y/N)"] })) : planApproval ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Approve this plan and begin implementation? (y/N)" }), _jsx(Text, { dimColor: true, children: planApproval.request.planPath }), planApproval.request.plan ? (_jsx(Text, { children: planApproval.request.plan })) : null] })) : question ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: [question.questions[question.index]?.header, ":", ' ', question.questions[question.index]?.question] }), question.questions[question.index]?.options.map((option, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [index + 1, ". ", option.label, " \u2014 ", option.description] }), option.preview ? (_jsx(Text, { dimColor: true, children: option.preview })) : null] }, `${index}-${option.label}`))), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: question.questions[question.index]?.multiSelect
-                                    ? 'Enter comma-separated option numbers or custom text · Esc cancels'
-                                    : 'Enter one option number or custom text · Esc cancels' })] })) : elicitation ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["MCP elicitation (", elicitation.request.serverName, "):", ' ', elicitation.request.message] }), elicitation.request.url ? (_jsx(Text, { children: elicitation.request.url })) : null, elicitation.request.requestedSchema ? (_jsx(Text, { dimColor: true, children: JSON.stringify(elicitation.request.requestedSchema) })) : null, _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter JSON object to accept \u00B7 Esc to cancel" })] })) : busy ? (_jsxs(Text, { dimColor: true, children: [status, "\u2026"] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["\u203A ", input] }), axScreenReader ? null : (_jsx(Text, { dimColor: true, children: "/new \u00B7 /sessions \u00B7 /workflows \u00B7 /exit" }))] }))] }))] }));
+    return (_jsx(Box, { flexDirection: "column", children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && history.length === 0 && !sessionId ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, _jsx(Transcript, { items: history, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded, screenReader: axScreenReader }), externalEditorRequest !== null || keybindingsEditing ? (_jsx(ExternalEditorWait, { screenReader: axScreenReader })) : permission ? (_jsxs(DialogFrame, { title: permission.kind === 'recovery'
+                        ? `Retry interrupted ${permission.call.name}?`
+                        : `Allow ${permission.call.name}?`, screenReader: axScreenReader, children: [_jsx(Text, { bold: true, children: describeTool(permission.call, sensitiveValues) }), _jsx(Text, { children: "\u276F 1. Yes" }), _jsx(Text, { children: " 2. No" }), _jsx(Text, { dimColor: true, children: "Enter/Esc declines \u00B7 y/n quick response" })] })) : planApproval ? (_jsxs(DialogFrame, { title: "Approve this plan and begin implementation?", screenReader: axScreenReader, children: [_jsx(Text, { dimColor: true, children: planApproval.request.planPath }), planApproval.request.plan ? (_jsx(Box, { marginY: 1, children: _jsx(Text, { children: planApproval.request.plan }) })) : null, _jsx(Text, { children: "\u276F 1. Yes, implement the plan" }), _jsx(Text, { children: " 2. No, keep planning" })] })) : question ? (_jsxs(DialogFrame, { title: `${question.questions[question.index]?.header}: ${question.questions[question.index]?.question}`, screenReader: axScreenReader, children: [question.questions[question.index]?.options.map((option, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [index === 0 ? '❯ ' : '  ', index + 1, ". ", option.label, " \u2014 ", option.description] }), option.preview ? (_jsx(Text, { dimColor: true, children: option.preview })) : null] }, `${index}-${option.label}`))), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: question.questions[question.index]?.multiSelect
+                                ? 'Enter comma-separated option numbers or custom text · Esc cancels'
+                                : 'Enter one option number or custom text · Esc cancels' })] })) : elicitation ? (_jsxs(DialogFrame, { title: `MCP elicitation (${elicitation.request.serverName})`, screenReader: axScreenReader, children: [_jsx(Text, { children: elicitation.request.message }), elicitation.request.url ? (_jsx(Text, { children: elicitation.request.url })) : null, elicitation.request.requestedSchema ? (_jsx(Text, { dimColor: true, children: JSON.stringify(elicitation.request.requestedSchema) })) : null, _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter JSON object to accept \u00B7 Esc to cancel" })] })) : menu?.kind === 'model-input' ? (_jsxs(DialogFrame, { title: "Enter model ID", screenReader: axScreenReader, children: [_jsx(Text, { dimColor: true, children: "Enter a model ID supported by the configured provider." }), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter confirms \u00B7 Esc cancels" })] })) : menu?.kind === 'export-filename' ? (_jsxs(DialogFrame, { title: "Enter filename:", screenReader: axScreenReader, children: [_jsxs(Text, { children: ["> ", input] }), _jsx(Text, { dimColor: true, children: "Enter to save \u00B7 Esc to go back" })] })) : menu?.kind === 'compact-progress' ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "\u273B Compacting conversation\u2026" }), _jsxs(Text, { children: ['▰'.repeat(Math.floor(compactProgress / 2)), '▱'.repeat(50 - Math.floor(compactProgress / 2)), ' ', compactProgress, "%"] })] })) : menu?.kind === 'rewind' ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " Rewind" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [' ', "Restore the code and/or conversation to the point before\u2026"] }), _jsx(Text, { children: " " }), (() => {
+                            const window = rewindPointWindow(menu.points, menu.selectedIndex);
+                            return (_jsxs(_Fragment, { children: [window.start > 0 ? (_jsxs(Text, { dimColor: true, children: [" \u2191 ", window.start, " more above"] })) : null, menu.points
+                                        .slice(window.start, window.end)
+                                        .map((point, offset) => {
+                                        const index = window.start + offset;
+                                        return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { inverse: menu.selectedIndex === index, children: [menu.selectedIndex === index ? ' ❯ ' : '   ', point.prompt.replace(/\s+/gu, ' ').slice(0, 72)] }), _jsxs(Text, { dimColor: true, children: ['     ', point.fileChanges.length > 0
+                                                            ? point.fileChanges
+                                                                .map((path) => path.startsWith(`${runtimeCwd}/`)
+                                                                ? path.slice(runtimeCwd.length + 1)
+                                                                : path)
+                                                                .join(', ')
+                                                            : point.fileRestoreAvailable
+                                                                ? 'No code changes'
+                                                                : '⚠ No code restore'] })] }, point.messageId));
+                                    }), window.end < menu.points.length ? (_jsxs(Text, { dimColor: true, children: [' ', "\u2193 ", menu.points.length - window.end, " more below"] })) : null] }));
+                        })(), _jsxs(Text, { inverse: menu.selectedIndex === menu.points.length, children: [menu.selectedIndex === menu.points.length ? ' ❯ ' : '   ', "(current)"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: " Enter to continue \u00B7 Esc to cancel" })] })) : menu?.kind === 'rewind-confirm' ? (_jsxs(DialogFrame, { title: "Confirm restore point", screenReader: axScreenReader, children: [_jsxs(Text, { children: ["\u2502 ", menu.point.prompt] }), _jsx(Text, { children: " " }), _jsx(Text, { children: "The conversation will be forked." }), _jsxs(Text, { children: ["The code will", ' ', menu.point.fileChanges.length > 0
+                                    ? `restore ${menu.point.fileChanges.join(', ')}.`
+                                    : 'be unchanged.'] }), _jsx(Text, { children: " " }), rewindActions(menu.point).map((option, index) => (_jsxs(Text, { inverse: menu.selectedIndex === index, children: [menu.selectedIndex === index ? '❯ ' : '  ', index + 1, ". ", option.label] }, option.action))), _jsx(Text, { children: " " }), _jsx(Text, { color: "yellow", children: "\u26A0 Rewinding does not affect files edited manually or via bash." })] })) : menu?.kind === 'rewind-context' ? (_jsxs(DialogFrame, { title: `Summarize ${menu.direction === 'from' ? 'from' : 'up to'} here`, screenReader: axScreenReader, children: [_jsx(Text, { children: menu.direction === 'from'
+                                ? 'Messages after this point will be summarized.'
+                                : 'Messages up to this point will be summarized.' }), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["add context (optional): ", input] }), _jsx(Text, { dimColor: true, children: "Enter to summarize \u00B7 Esc to go back" })] })) : menu?.kind === 'permission-rule-input' ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Add ", menu.behavior, " permission rule"] }), _jsx(Text, { children: "Permission rules are a tool name, optionally followed by a specifier in parentheses." }), _jsx(Text, { children: "e.g., WebFetch or Bash(ls *)" }), _jsx(Text, { children: " " }), _jsx(Box, { borderStyle: axScreenReader ? undefined : 'round', paddingX: axScreenReader ? 0 : 1, children: _jsx(Text, { ...(input ? {} : { dimColor: true }), children: input || 'Enter permission rule…' }) }), _jsx(Text, { dimColor: true, children: "Enter to submit \u00B7 Esc to cancel" })] })) : menu?.kind === 'workspace-directory-input' ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Add directory to workspace" }), _jsx(Text, { children: "Praxis Code will be able to read files in this directory and make edits when auto-accept edits is on." }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Enter the path to the directory:" }), _jsx(Box, { borderStyle: axScreenReader ? undefined : 'round', paddingX: axScreenReader ? 0 : 1, children: _jsx(Text, { ...(input ? {} : { dimColor: true }), children: input || 'Directory path…' }) }), _jsx(Text, { dimColor: true, children: "Tab to complete \u00B7 Enter to add \u00B7 Esc to cancel" })] })) : menu?.kind === 'permission-delete' ? (_jsxs(DialogFrame, { title: permissionDeleteTitle(menu.rule.behavior), screenReader: axScreenReader, children: [_jsx(Text, { children: menu.rule.rule }), permissionRuleDescription(menu.rule.rule) ? (_jsx(Text, { dimColor: true, children: permissionRuleDescription(menu.rule.rule) })) : null, _jsx(Text, { dimColor: true, children: permissionScopeLabel(menu.rule.scope) }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Are you sure you want to delete this permission rule?" }), _jsx(Text, { children: " " }), _jsxs(Text, { inverse: menu.selectedIndex === 0, children: [menu.selectedIndex === 0 ? '❯ ' : '  ', "1. Yes"] }), _jsxs(Text, { inverse: menu.selectedIndex === 1, children: [menu.selectedIndex === 1 ? '❯ ' : '  ', "2. No"] }), _jsx(Text, { dimColor: true, children: "Esc to cancel" })] })) : menu?.kind === 'workspace-directory-delete' ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Remove directory from workspace?" }), _jsxs(Text, { children: [" ", menu.path] }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Praxis Code will no longer have access to files in this directory." }), _jsx(Text, { children: " " }), _jsxs(Text, { inverse: menu.selectedIndex === 0, children: [menu.selectedIndex === 0 ? '❯ ' : '  ', "1. Yes"] }), _jsxs(Text, { inverse: menu.selectedIndex === 1, children: [menu.selectedIndex === 1 ? '❯ ' : '  ', "2. No"] }), _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Esc to cancel" })] })) : menu ? (menu.kind === 'help' ? (_jsx(HelpMenu, { tabIndex: menu.tabIndex, selectedIndex: menu.selectedIndex, builtinCommands: builtinSlashCommands, customCommands: customSlashCommands, width: width, screenReader: axScreenReader })) : menu.kind === 'diff' ? (_jsx(DiffDashboard, { snapshots: menu.snapshots, sourceIndex: menu.sourceIndex, selectedIndex: menu.selectedIndex, viewingFile: menu.viewingFile, scrollOffset: menu.scrollOffset, width: width, screenReader: axScreenReader })) : menu.kind === 'permission-dashboard' ? (_jsx(PermissionDashboard, { tabIndex: menu.tabIndex, selectedIndex: menu.selectedIndex, query: menu.query, rules: menu.rules, recentDenied: recentDenied, workspaceDirectories: workspaceDirectories, width: width, screenReader: axScreenReader })) : menu.kind === 'permission-scope' ? (_jsx(SelectionMenu, { title: "Where should this rule be saved?", description: `${menu.rule}${permissionRuleDescription(menu.rule)
+                        ? ` · ${permissionRuleDescription(menu.rule)}`
+                        : ''}`, options: [
+                        {
+                            label: 'Project settings (local)',
+                            description: 'Saved in .claude/settings.local.json',
+                        },
+                        {
+                            label: 'Project settings',
+                            description: 'Checked in at .claude/settings.json',
+                        },
+                        {
+                            label: 'User settings',
+                            description: 'Saved in at ~/.claude/settings.json',
+                        },
+                    ], selectedIndex: menu.selectedIndex, footer: "Enter to confirm \u00B7 Esc to cancel", width: width, screenReader: axScreenReader })) : menu.kind === 'status' ? (_jsx(StatusDashboard, { tabIndex: menu.tabIndex, version: runtimeDisplay.version, sessionId: sessionId, display: runtimeDisplay, ...(usage === undefined ? {} : { usage }), ...(costUsd === undefined ? {} : { costUsd }), turnCount: turnNumberRef.current, toolCount: history.filter((item) => item.kind === 'tool').length, commandCount: allSlashCommands.length, detailedTranscript: thinkingExpanded, width: width, screenReader: axScreenReader })) : menu.kind === 'list' ? (_jsx(ListDashboard, { title: menu.title, rows: menu.rows, emptyText: menu.emptyText, selectedIndex: menu.selectedIndex, width: width, screenReader: axScreenReader })) : menu.kind === 'model' ? (_jsx(SelectionMenu, { title: "Select model", description: `Effort: ${runtimePreferences.effort}`, options: modelOptions, selectedIndex: menu.selectedIndex, footer: "\u2191/\u2193 select \u00B7 \u2190/\u2192 effort \u00B7 Enter applies to this session \u00B7 Esc cancels", width: width, screenReader: axScreenReader })) : menu.kind === 'effort' ? (_jsx(SelectionMenu, { title: "Select effort", description: "Controls how much reasoning effort the provider should use.", options: EFFORT_OPTIONS.map((option) => ({
+                        label: option,
+                        description: option === 'low'
+                            ? 'Fastest and least deliberative.'
+                            : option === 'max'
+                                ? 'Highest available reasoning effort.'
+                                : 'Use this effort for the next session turns.',
+                        selected: option === runtimePreferences.effort,
+                    })), selectedIndex: menu.selectedIndex, footer: "\u2191/\u2193 select \u00B7 Enter applies to this session \u00B7 Esc cancels", width: width, screenReader: axScreenReader })) : menu.kind === 'export' ? (_jsx(SelectionMenu, { title: "Export conversation", description: "Select export method", options: [
+                        {
+                            label: 'Copy to clipboard',
+                            description: 'Copy the conversation to your system clipboard',
+                        },
+                        {
+                            label: 'Save to file',
+                            description: 'Save the conversation to a file in the current directory',
+                        },
+                    ], selectedIndex: menu.selectedIndex, footer: "Esc to cancel", width: width, screenReader: axScreenReader })) : null) : (_jsxs(_Fragment, { children: [commandPaletteVisible ? (_jsx(CommandPalette, { commands: matchingSlashCommands, selectedIndex: selectedSlashCommandIndex, width: width, screenReader: axScreenReader })) : null, filePickerVisible ? (_jsx(MentionPicker, { entries: matchingMentionEntries, selectedIndex: selectedFileIndex, width: width, screenReader: axScreenReader })) : null, exitConfirmation ? (_jsx(Text, { color: "yellow", children: "Press Ctrl-C again to exit" })) : null, _jsx(Composer, { input: shellMode ? input.slice(1) : input, cursor: shellMode ? Math.max(0, inputCursor - 1) : inputCursor, shellMode: shellMode, busy: busy, clipboardBusy: clipboardBusy, status: status, display: runtimeDisplay, ...(usage === undefined ? {} : { usage }), ...(costUsd === undefined ? {} : { costUsd }), width: width, screenReader: axScreenReader, hasThinking: hasDetailedTranscript, thinkingExpanded: thinkingExpanded, shortcutsVisible: shortcutsVisible, ...(editorFooterMessage === undefined
+                                ? {}
+                                : { footerMessage: editorFooterMessage }) })] }))] })) }));
 }
 export async function runInteractive(options) {
     const controller = new AbortController();
@@ -554,11 +3084,15 @@ export async function runInteractive(options) {
         signal,
     });
     let initialSessions;
+    let initialSlashCommands;
+    let initialAgents;
     try {
         const sessions = await listing.sessions();
         initialSessions = options.sessionFilter
             ? sessions.filter(options.sessionFilter)
             : sessions;
+        initialSlashCommands = listing.slashCommands?.() ?? [];
+        initialAgents = listing.agentDefinitions?.() ?? [];
         if (options.requireSession && initialSessions.length === 0) {
             throw new Error(options.missingSessionMessage ??
                 'No conversation linked to a pull request in this project');
@@ -573,7 +3107,6 @@ export async function runInteractive(options) {
         }
         throw error;
     }
-    await listing.close?.();
     const canonicalResumeSession = options.resume?.sessionId === undefined
         ? undefined
         : initialSessions.find((session) => session.sessionId.toLowerCase() ===
@@ -581,15 +3114,40 @@ export async function runInteractive(options) {
     const resume = canonicalResumeSession
         ? { ...options.resume, sessionId: canonicalResumeSession.sessionId }
         : options.resume;
+    let initialHistory = [];
+    try {
+        initialHistory =
+            resume?.sessionId === undefined || listing.transcript === undefined
+                ? []
+                : await listing.transcript(resume.sessionId);
+    }
+    catch (error) {
+        try {
+            await listing.close?.();
+        }
+        catch {
+            // Preserve the transcript-loading failure as the primary error.
+        }
+        throw error;
+    }
+    await listing.close?.();
     let activeTurn = null;
     let cleanup = null;
-    const instance = render(_jsx(InteractiveApp, { factory: options.factory, initialSessions: initialSessions, ...(options.initialPrompt === undefined
+    const instance = render(_jsx(InteractiveApp, { factory: options.factory, initialSessions: initialSessions, slashCommands: initialSlashCommands, agents: initialAgents, initialHistory: initialHistory, ...(options.initialPrompt === undefined
             ? {}
             : { initialPrompt: options.initialPrompt }), signal: signal, onCancel: () => controller.abort(), onTurnChange: (turn) => {
             activeTurn = turn;
         }, onCleanup: (closing) => {
             cleanup = closing;
-        }, allowNewSession: !options.requireSession, ...(resume === undefined ? {} : { resume }), ...(options.axScreenReader ? { axScreenReader: true } : {}) }), { exitOnCtrlC: false, incrementalRendering: !options.axScreenReader });
+        }, allowNewSession: !options.requireSession, ...(options.additionalDirectories === undefined
+            ? {}
+            : { additionalDirectories: options.additionalDirectories }), ...(resume === undefined ? {} : { resume }), ...(options.display === undefined ? {} : { display: options.display }), ...(options.axScreenReader ? { axScreenReader: true } : {}), ...(options.allowDangerouslySkipPermissions
+            ? { allowDangerouslySkipPermissions: true }
+            : {}) }), {
+        exitOnCtrlC: false,
+        incrementalRendering: !options.axScreenReader,
+        interactive: true,
+    });
     await instance.waitUntilExit();
     if (activeTurn)
         await activeTurn;