@wangzhizhi/remi 0.0.1-alpha

package/dist/tui/RemiApp.js

@@ -0,0 +1,1756 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { Box, Text, useApp, useInput, useWindowSize } from 'ink';
+import { estimateSessionContextTrace, runChatTurn } from '@remi/core';
+import { compactSession } from '@remi/compact';
+import { loadRemiConfig, normalizePermissionProfile } from '@remi/config';
+import { createModelRouter } from '@remi/llm';
+import { loadSkillIndex } from '@remi/skills';
+import { appendProjectInputHistory, createNewSession, readProjectInputHistory, readSessionEvents, readSessionPermissionRules, readSessionUserInputs, resolveActiveSessionId, writeSessionPermissionRules, } from '@remi/sessions';
+import { createSkillsListPanelMessage, executeSlashCommand, listSlashCommands, saveProjectDisabledSkills } from './commands.js';
+import { Header } from './renderers/Header.js';
+import { MessageList, PlanMessage } from './renderers/MessageList.js';
+import { PromptBox } from './renderers/PromptBox.js';
+import { StatusLine } from './renderers/StatusLine.js';
+import { loadGitStatus } from '../git.js';
+import { languageLabel, resolveConfiguredLanguage, saveProjectLanguage, t } from '../i18n.js';
+import { addSessionPermissionRules, formatPermissionProfileChanged, formatPermissionRulesScope, resolveConfiguredPermissionProfile, saveProjectPermissionRule, saveProjectPermissionProfile, } from '../permissions.js';
+import { formatResponseStyleChanged, resolveConfiguredResponseStyle, saveProjectResponseStyle } from '../style.js';
+import { formatSyntaxThemeChanged, resolveConfiguredSyntaxTheme, saveProjectSyntaxTheme } from '../syntaxTheme.js';
+import { defaultStatusLineItems, getStatusLineCatalog, resolveConfiguredStatusLineItems, saveProjectStatusLineItems } from '../statusline.js';
+import { addTokenUsage, contextRemainingPercentFromUsage, createEmptyTokenUsage, formatTokenUsage, sumSessionTokenUsage } from '../usage.js';
+import { formatPermissionFileAction } from '../permissionDisplay.js';
+import { saveProjectMainModel } from '../modelSelection.js';
+import { remiDarkTheme } from './theme.js';
+const assistantStreamFlushIntervalMs = 24;
+const assistantStreamImmediateFlushChars = 32;
+function isPrintableInput(input) {
+    return input.length > 0 && !/[\u0000-\u001f\u007f]/.test(input);
+}
+function estimateInitialContextRemainingPercent(cwd, sessionId) {
+    try {
+        return estimateSessionContextTrace(sessionId ? { cwd, sessionId } : { cwd })?.remainingPercent;
+    }
+    catch {
+        return undefined;
+    }
+}
+const exitResponseDelayMs = 20;
+const compactProgressDelayMs = 20;
+const queuedPromptAbortReason = 'queued-prompt-dispatch';
+function abortSignalReasonMessage(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    return typeof reason === 'string' ? reason : undefined;
+}
+function isQueuedPromptDispatchAbort(signal, message) {
+    return signal.aborted && (message === queuedPromptAbortReason || abortSignalReasonMessage(signal) === queuedPromptAbortReason);
+}
+function isSlashCommandInput(input) {
+    const normalized = input.trim();
+    return normalized.startsWith('/') || ['help', 'exit', 'quit'].includes(normalized);
+}
+function buildQueuedPromptDispatch(previousUserInput, queuedText) {
+    if (isSlashCommandInput(queuedText)) {
+        return { visibleText: queuedText, modelInput: queuedText };
+    }
+    return {
+        visibleText: queuedText,
+        modelInput: [
+            'A user submitted additional guidance while the previous request was running.',
+            'Treat the queued guidance as a continuation or confirmation for the same objective, not as an isolated new task.',
+            '',
+            'Previous user request:',
+            previousUserInput,
+            '',
+            'Queued guidance:',
+            queuedText,
+        ].join('\n'),
+    };
+}
+function visibleMessagesWithoutPlanUpdates(messages) {
+    return messages.filter(message => message.kind !== 'plan-update');
+}
+function latestPlanItemsFromMessages(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message?.kind === 'plan-update') {
+            return message.items;
+        }
+    }
+    return undefined;
+}
+function trimOneWord(value) {
+    return value.trimEnd().replace(/\s*\S+$/, '');
+}
+function inputLength(value) {
+    return Array.from(value).length;
+}
+function loadInputHistory(cwd, sessionId) {
+    return mergeInputHistory(readProjectInputHistory(cwd), readSessionUserInputs(cwd, sessionId));
+}
+function mergeInputHistory(...sources) {
+    return sources.reduce((history, source) => {
+        return source.reduce((current, value) => appendInputHistoryEntry(current, value), history);
+    }, []);
+}
+function appendInputHistoryEntry(history, value) {
+    const normalized = value.trim();
+    if (normalized.length === 0 || history[history.length - 1] === normalized) {
+        return history;
+    }
+    return [...history, normalized].slice(-200);
+}
+function clampInputCursor(cursor, value) {
+    return Math.max(0, Math.min(inputLength(value), cursor));
+}
+function insertInputText(value, cursor, insertedText) {
+    const chars = Array.from(value);
+    const insertedChars = Array.from(insertedText);
+    const safeCursor = Math.max(0, Math.min(chars.length, cursor));
+    chars.splice(safeCursor, 0, ...insertedChars);
+    return { value: chars.join(''), cursor: safeCursor + insertedChars.length };
+}
+function deleteInputBeforeCursor(value, cursor) {
+    const chars = Array.from(value);
+    const safeCursor = Math.max(0, Math.min(chars.length, cursor));
+    if (safeCursor === 0) {
+        return { value, cursor: safeCursor };
+    }
+    chars.splice(safeCursor - 1, 1);
+    return { value: chars.join(''), cursor: safeCursor - 1 };
+}
+function deleteInputAtCursor(value, cursor) {
+    const chars = Array.from(value);
+    const safeCursor = Math.max(0, Math.min(chars.length, cursor));
+    if (safeCursor >= chars.length) {
+        return { value, cursor: safeCursor };
+    }
+    chars.splice(safeCursor, 1);
+    return { value: chars.join(''), cursor: safeCursor };
+}
+function trimOneWordBeforeCursor(value, cursor) {
+    const chars = Array.from(value);
+    const safeCursor = Math.max(0, Math.min(chars.length, cursor));
+    const before = chars.slice(0, safeCursor).join('');
+    const after = chars.slice(safeCursor).join('');
+    const trimmedBefore = trimOneWord(before);
+    return { value: `${trimmedBefore}${after}`, cursor: inputLength(trimmedBefore) };
+}
+export function RemiApp({ cwd = process.cwd(), chatRunner = runChatTurn, initialMessages = [], initialSessionId, onTokenUsage, onSessionId, width, }) {
+    const { exit } = useApp();
+    const { columns } = useWindowSize();
+    const activeAbortController = useRef(undefined);
+    const initialResolvedSessionId = useRef(undefined);
+    initialResolvedSessionId.current ??= initialSessionId ?? resolveActiveSessionId(cwd);
+    const initialUsageTotals = useRef(undefined);
+    initialUsageTotals.current ??= sumSessionTokenUsage(readSessionEvents(cwd, initialResolvedSessionId.current ?? resolveActiveSessionId(cwd)));
+    const initialVisibleMessages = useRef(undefined);
+    initialVisibleMessages.current ??= visibleMessagesWithoutPlanUpdates(initialMessages);
+    const initialPlanItems = useRef(undefined);
+    initialPlanItems.current ??= latestPlanItemsFromMessages(initialMessages);
+    const initialContextRemainingPercent = useRef(undefined);
+    initialContextRemainingPercent.current ??= estimateInitialContextRemainingPercent(cwd, initialResolvedSessionId.current);
+    const [input, setInput] = useState('');
+    const [inputCursor, setInputCursor] = useState(0);
+    const [sessionId, setSessionId] = useState(() => initialResolvedSessionId.current ?? resolveActiveSessionId(cwd));
+    const [messages, setMessages] = useState(initialVisibleMessages.current ?? []);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [workingStartedAt, setWorkingStartedAt] = useState(undefined);
+    const [progressLabelOverride, setProgressLabelOverride] = useState(undefined);
+    const [selectedCommandIndex, setSelectedCommandIndex] = useState(0);
+    const [mainModelAlias, setMainModelAlias] = useState(undefined);
+    const [language, setLanguage] = useState(() => resolveConfiguredLanguage(cwd));
+    const [responseStyle, setResponseStyle] = useState(() => resolveConfiguredResponseStyle(cwd));
+    const [syntaxTheme, setSyntaxTheme] = useState(() => resolveConfiguredSyntaxTheme(cwd));
+    const [permissionProfile, setPermissionProfile] = useState(() => resolveConfiguredPermissionProfile(cwd));
+    const [fixedPlanItems, setFixedPlanItems] = useState(initialPlanItems.current);
+    const [queuedPrompts, setQueuedPrompts] = useState([]);
+    const queuedPromptsRef = useRef([]);
+    const queuedPromptIdRef = useRef(0);
+    const [pendingQueuedDispatch, setPendingQueuedDispatch] = useState(undefined);
+    const [statusLineItems, setStatusLineItems] = useState(() => resolveConfiguredStatusLineItems(cwd));
+    const [contextRemainingPercent, setContextRemainingPercent] = useState(initialContextRemainingPercent.current);
+    const [usageTotals, setUsageTotals] = useState(() => initialUsageTotals.current ?? createEmptyTokenUsage());
+    const [inputHistory, setInputHistory] = useState(() => loadInputHistory(cwd, initialResolvedSessionId.current ?? resolveActiveSessionId(cwd)));
+    const [historyCursor, setHistoryCursor] = useState(undefined);
+    const [historyDraft, setHistoryDraft] = useState('');
+    const initialSessionPermissionRules = useRef(undefined);
+    initialSessionPermissionRules.current ??= readSessionPermissionRules(cwd, sessionId);
+    const sessionPermissionRules = useRef(initialSessionPermissionRules.current);
+    const pendingPermission = useRef(undefined);
+    const isStatusLinePanelOpen = useMemo(() => {
+        const panelIndex = findLastStatusLinePanelIndex(messages);
+        return panelIndex === findLastPickerPanelIndex(messages) && messages[panelIndex]?.kind === 'statusline-panel';
+    }, [messages]);
+    const isSyntaxThemePanelOpen = useMemo(() => {
+        const panelIndex = findLastSyntaxThemePanelIndex(messages);
+        return panelIndex === findLastPickerPanelIndex(messages) && messages[panelIndex]?.kind === 'syntax-theme-panel';
+    }, [messages]);
+    const isPermissionRequestOpen = useMemo(() => {
+        const panelIndex = findLastPermissionRequestIndex(messages);
+        return panelIndex === findLastPickerPanelIndex(messages) && messages[panelIndex]?.kind === 'permission-request';
+    }, [messages]);
+    const isSkillsPanelOpen = useMemo(() => {
+        const panelIndex = findLastSkillsPanelIndex(messages);
+        return panelIndex === findLastPickerPanelIndex(messages) && messages[panelIndex]?.kind === 'skills-panel';
+    }, [messages]);
+    const bottomPanelIndex = useMemo(() => findActiveBottomPanelIndex(messages), [messages]);
+    const bottomPanelMessage = bottomPanelIndex >= 0 ? messages[bottomPanelIndex] : undefined;
+    const mainMessages = useMemo(() => (bottomPanelIndex >= 0 ? messages.filter((_, index) => index !== bottomPanelIndex) : messages), [bottomPanelIndex, messages]);
+    const previewStatusLineItems = useMemo(() => {
+        const panelIndex = findLastStatusLinePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex === findLastPickerPanelIndex(messages) && panel?.kind === 'statusline-panel') {
+            return statusLineItemsFromPanel(panel);
+        }
+        return statusLineItems;
+    }, [messages, statusLineItems]);
+    useEffect(() => {
+        onSessionId?.(sessionId);
+    }, [onSessionId, sessionId]);
+    const status = useMemo(() => {
+        try {
+            const loaded = loadRemiConfig({ cwd });
+            const router = createModelRouter(loaded.config);
+            if (mainModelAlias) {
+                router.switchRoleModel('main', mainModelAlias);
+            }
+            const resolved = router.resolve('main');
+            const git = loadGitStatus(cwd);
+            const resolvedPermissionProfile = permissionProfile ?? normalizePermissionProfile(loaded.config.permissions);
+            const permissionMode = loaded.config.permissions?.mode ?? (resolvedPermissionProfile === 'full-access' ? 'bypass' : 'auto');
+            return {
+                cwd,
+                profile: resolved.profile,
+                model: resolved.displayName ?? resolved.alias,
+                role: resolved.role,
+                sessionId,
+                permissionMode,
+                permissionProfile: resolvedPermissionProfile,
+                ...(contextRemainingPercent !== undefined ? { contextRemainingPercent } : {}),
+                ...(git ? { git } : {}),
+                statusLineItems: previewStatusLineItems,
+                usage: usageTotals,
+                runState: isSubmitting ? (workingStartedAt === undefined ? 'Working' : 'Thinking') : 'Ready',
+                language,
+                mcpCount: 0,
+                skillCount: loadEnabledSkillCount(cwd, loaded.config.skills?.disabled),
+            };
+        }
+        catch {
+            return {
+                cwd,
+                profile: 'unset',
+                model: 'unconfigured',
+                role: 'main',
+                sessionId,
+                permissionMode: 'readonly',
+                permissionProfile,
+                ...(contextRemainingPercent !== undefined ? { contextRemainingPercent } : {}),
+                statusLineItems: previewStatusLineItems,
+                usage: usageTotals,
+                runState: isSubmitting ? (workingStartedAt === undefined ? 'Working' : 'Thinking') : 'Ready',
+                language,
+                mcpCount: 0,
+                skillCount: 0,
+            };
+        }
+    }, [contextRemainingPercent, cwd, isSubmitting, language, mainModelAlias, permissionProfile, previewStatusLineItems, sessionId, usageTotals, workingStartedAt]);
+    const commandHints = useMemo(() => listSlashCommands(language).map(command => ({
+        name: command.name,
+        description: command.description,
+    })), [language]);
+    const activeCommandHints = historyCursor === undefined ? commandHints : [];
+    const prompt = {
+        value: input,
+        cursorPosition: clampInputCursor(inputCursor, input),
+        mode: 'prompt',
+        placeholder: isSubmitting ? t(language, 'prompt.queue.placeholder') : t(language, 'prompt.placeholder'),
+        queuedCommands: [],
+        commandHints: activeCommandHints,
+        selectedCommandIndex: normalizeIndex(selectedCommandIndex, visibleCommandHintsForInput(input, activeCommandHints).length),
+    };
+    const viewportWidth = width ?? columns;
+    const appendMessage = useCallback((message) => {
+        setMessages(current => {
+            const base = message.kind === 'model-panel' ||
+                message.kind === 'style-panel' ||
+                message.kind === 'syntax-theme-panel' ||
+                message.kind === 'statusline-panel' ||
+                message.kind === 'language-panel' ||
+                message.kind === 'permission-profile-panel' ||
+                message.kind === 'skills-panel'
+                ? current.filter(existing => existing.kind !== 'model-panel' &&
+                    existing.kind !== 'style-panel' &&
+                    existing.kind !== 'syntax-theme-panel' &&
+                    existing.kind !== 'statusline-panel' &&
+                    existing.kind !== 'language-panel' &&
+                    existing.kind !== 'permission-profile-panel' &&
+                    existing.kind !== 'skills-panel')
+                : current;
+            return [...base, message];
+        });
+    }, []);
+    const updateQueuedPrompts = useCallback((updater) => {
+        const next = updater(queuedPromptsRef.current);
+        queuedPromptsRef.current = next;
+        setQueuedPrompts(next);
+    }, []);
+    const enqueuePrompt = useCallback((text) => {
+        const normalized = text.trim();
+        if (normalized.length === 0) {
+            return false;
+        }
+        queuedPromptIdRef.current += 1;
+        const prompt = { id: queuedPromptIdRef.current, text: normalized };
+        updateQueuedPrompts(current => [...current, prompt]);
+        return true;
+    }, [updateQueuedPrompts]);
+    const consumeQueuedPromptText = useCallback(() => {
+        const prompts = queuedPromptsRef.current;
+        if (prompts.length === 0) {
+            return undefined;
+        }
+        updateQueuedPrompts(() => []);
+        return prompts.map(prompt => prompt.text).join('\n\n');
+    }, [updateQueuedPrompts]);
+    const queueCurrentInput = useCallback(() => {
+        const queued = enqueuePrompt(input);
+        if (!queued) {
+            return false;
+        }
+        setInput('');
+        setInputCursor(0);
+        setSelectedCommandIndex(0);
+        setHistoryCursor(undefined);
+        setHistoryDraft('');
+        return true;
+    }, [enqueuePrompt, input]);
+    const requestExit = useCallback((message, userInput) => {
+        setMessages(current => {
+            const next = [...finalizeStreamingMessages(current)];
+            if (userInput) {
+                next.push({ kind: 'user', text: userInput });
+            }
+            if (message) {
+                next.push(message);
+            }
+            return next;
+        });
+        setTimeout(() => exit(), exitResponseDelayMs);
+    }, [exit]);
+    const requestToolPermission = useCallback(async (request, decision) => {
+        const requestId = `permission-${request.toolName}-${Date.now()}`;
+        const message = permissionRequestMessage(requestId, request, decision, language);
+        setWorkingStartedAt(undefined);
+        setMessages(current => [...finalizeStreamingMessages(current), message]);
+        return await new Promise(resolve => {
+            pendingPermission.current = { decision, resolve };
+        });
+    }, [language]);
+    const submit = useCallback(async (inputOverride) => {
+        if (isSubmitting) {
+            return;
+        }
+        const value = (typeof inputOverride === 'object' ? inputOverride.visibleText : (inputOverride ?? input)).trim();
+        const overrideModelInput = typeof inputOverride === 'object' ? inputOverride.modelInput.trim() : undefined;
+        setInput('');
+        setInputCursor(0);
+        setSelectedCommandIndex(0);
+        setHistoryCursor(undefined);
+        setHistoryDraft('');
+        if (value.length === 0) {
+            return;
+        }
+        appendProjectInputHistory(cwd, value, sessionId);
+        setInputHistory(current => appendInputHistoryEntry(current, value));
+        let chatInput = overrideModelInput ?? value;
+        const visibleUserInput = value;
+        if (isSlashCommandInput(value)) {
+            const context = mainModelAlias
+                ? { cwd, sessionId, mainModelAlias, responseStyle, syntaxTheme, statusLineItems, language, permissionProfile }
+                : { cwd, sessionId, responseStyle, syntaxTheme, statusLineItems, language, permissionProfile };
+            const result = executeSlashCommand(value, context);
+            if (result.kind === 'exit') {
+                requestExit(undefined, value);
+                return;
+            }
+            if (result.kind === 'new-session') {
+                const previousUsage = formatTokenUsage(usageTotals, language);
+                const nextSessionId = createNewSession(cwd);
+                setSessionId(nextSessionId);
+                sessionPermissionRules.current = readSessionPermissionRules(cwd, nextSessionId);
+                setUsageTotals(createEmptyTokenUsage());
+                setContextRemainingPercent(estimateInitialContextRemainingPercent(cwd, nextSessionId));
+                setFixedPlanItems(undefined);
+                updateQueuedPrompts(() => []);
+                setMessages([{ kind: 'user', text: value }, { kind: 'session-switch', previousUsage, sessionId: nextSessionId, label: t(language, 'session.new') }]);
+                return;
+            }
+            if (result.kind === 'prompt') {
+                chatInput = result.prompt;
+            }
+            else {
+                appendMessage({ kind: 'user', text: value });
+                if (result.kind === 'style') {
+                    setResponseStyle(result.styleId);
+                    saveProjectResponseStyle(cwd, result.styleId);
+                    appendMessage({ kind: 'system', level: 'info', text: formatResponseStyleChanged(result.styleId, true, language) });
+                    return;
+                }
+                if (result.kind === 'syntax-theme') {
+                    setSyntaxTheme(result.themeId);
+                    saveProjectSyntaxTheme(cwd, result.themeId);
+                    appendMessage({ kind: 'system', level: 'info', text: formatSyntaxThemeChanged(result.themeId, true, language) });
+                    return;
+                }
+                if (result.kind === 'language') {
+                    setLanguage(result.language);
+                    saveProjectLanguage(cwd, result.language);
+                    appendMessage({ kind: 'system', level: 'info', text: t(result.language, 'language.saved', { label: languageLabel(result.language) }) });
+                    return;
+                }
+                if (result.kind === 'permission-profile') {
+                    setPermissionProfile(result.profile);
+                    saveProjectPermissionProfile(cwd, result.profile);
+                    appendMessage(result.message);
+                    return;
+                }
+                if (result.kind === 'compact') {
+                    if (!sessionId) {
+                        appendMessage({ kind: 'system', level: 'warn', text: t(language, 'compact.noActive') });
+                        return;
+                    }
+                    setIsSubmitting(true);
+                    setWorkingStartedAt(Date.now());
+                    setProgressLabelOverride(t(language, 'compact.progress'));
+                    try {
+                        await new Promise(resolve => setTimeout(resolve, compactProgressDelayMs));
+                        const compactResult = compactSession(cwd, sessionId);
+                        appendMessage({
+                            kind: 'compact-boundary',
+                            summary: t(language, 'compact.done', {
+                                count: compactResult.sourceEventCount,
+                                tokens: compactResult.estimatedTokens,
+                            }),
+                        });
+                    }
+                    catch (error) {
+                        appendMessage({
+                            kind: 'system',
+                            level: 'error',
+                            text: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    finally {
+                        setIsSubmitting(false);
+                        setWorkingStartedAt(undefined);
+                        setProgressLabelOverride(undefined);
+                    }
+                    return;
+                }
+                appendMessage(result.message);
+                return;
+            }
+        }
+        const taskStartedAt = Date.now();
+        setIsSubmitting(true);
+        setWorkingStartedAt(taskStartedAt);
+        setProgressLabelOverride(undefined);
+        setMessages(current => [...current, { kind: 'user', text: visibleUserInput }]);
+        const abortController = new AbortController();
+        activeAbortController.current = abortController;
+        let pendingAssistantText = '';
+        let assistantFlushTimer;
+        let lastAssistantFlushAt = 0;
+        const flushAssistantText = () => {
+            if (assistantFlushTimer) {
+                clearTimeout(assistantFlushTimer);
+                assistantFlushTimer = undefined;
+            }
+            if (pendingAssistantText.length === 0) {
+                return;
+            }
+            const text = pendingAssistantText;
+            pendingAssistantText = '';
+            lastAssistantFlushAt = Date.now();
+            setMessages(current => appendAssistantDelta(current, text));
+        };
+        const scheduleAssistantFlush = (delayMs = assistantStreamFlushIntervalMs) => {
+            if (assistantFlushTimer) {
+                return;
+            }
+            assistantFlushTimer = setTimeout(() => {
+                assistantFlushTimer = undefined;
+                flushAssistantText();
+            }, delayMs);
+        };
+        const queueAssistantText = (text) => {
+            pendingAssistantText += text;
+            const now = Date.now();
+            const elapsedSinceFlush = lastAssistantFlushAt === 0 ? Infinity : now - lastAssistantFlushAt;
+            if (lastAssistantFlushAt === 0 ||
+                elapsedSinceFlush >= assistantStreamFlushIntervalMs ||
+                pendingAssistantText.length >= assistantStreamImmediateFlushChars ||
+                text.includes('\n')) {
+                flushAssistantText();
+                return;
+            }
+            scheduleAssistantFlush(Math.max(1, assistantStreamFlushIntervalMs - elapsedSinceFlush));
+        };
+        let sawUsageEvent = false;
+        let activeContextWindowTokens;
+        try {
+            const chatConfig = {
+                cwd,
+                sessionId,
+                responseStyle,
+                permissionProfile,
+                requestToolPermission,
+                permissionRules: () => sessionPermissionRules.current,
+                signal: abortController.signal,
+                ...(mainModelAlias ? { modelOverrides: { main: mainModelAlias } } : {}),
+            };
+            for await (const event of chatRunner(chatInput, chatConfig)) {
+                if (event.type === 'start') {
+                    setSessionId(event.sessionId);
+                    activeContextWindowTokens = event.contextTrace?.contextWindowTokens;
+                    if (event.contextTrace?.remainingPercent !== undefined) {
+                        setContextRemainingPercent(event.contextTrace.remainingPercent);
+                    }
+                    setMessages(current => [
+                        ...current,
+                        { kind: 'assistant', text: '', streaming: true },
+                    ]);
+                }
+                else if (event.type === 'compact_start') {
+                    setWorkingStartedAt(Date.now());
+                    setProgressLabelOverride(t(language, 'compact.progress'));
+                }
+                else if (event.type === 'compact') {
+                    setMessages(current => [
+                        ...finalizeStreamingMessages(current),
+                        {
+                            kind: 'compact-boundary',
+                            summary: t(language, 'compact.done', {
+                                count: event.sourceEventCount,
+                                tokens: event.estimatedTokens,
+                            }),
+                        },
+                    ]);
+                }
+                else if (event.type === 'compact_end') {
+                    setProgressLabelOverride(undefined);
+                }
+                else if (event.type === 'skill_use') {
+                    setMessages(current => [
+                        ...finalizeStreamingMessages(current),
+                        {
+                            kind: 'skill-use',
+                            name: event.name,
+                            displayName: event.displayName,
+                            source: event.source,
+                            filePath: event.filePath,
+                        },
+                    ]);
+                }
+                else if (event.type === 'delta') {
+                    setWorkingStartedAt(undefined);
+                    queueAssistantText(event.text);
+                }
+                else if (event.type === 'tool_call') {
+                    setWorkingStartedAt(undefined);
+                    flushAssistantText();
+                    setMessages(current => [
+                        ...finalizeStreamingMessages(current),
+                        { kind: 'tool-call', callId: event.callId, toolName: event.toolName, summary: event.summary, state: 'running', startedAt: Date.now() },
+                    ]);
+                }
+                else if (event.type === 'tool_result') {
+                    setWorkingStartedAt(Date.now());
+                    flushAssistantText();
+                    if (event.recoverable) {
+                        setMessages(current => removeMatchingToolCall(finalizeStreamingMessages(current), event.callId));
+                        continue;
+                    }
+                    setMessages(current => replaceToolCallWithResult(finalizeStreamingMessages(current), {
+                        kind: 'tool-result',
+                        callId: event.callId,
+                        toolName: event.toolName,
+                        summary: event.summary,
+                        ...(event.detail ? { detail: event.detail } : {}),
+                        state: event.ok ? 'done' : 'failed',
+                    }));
+                    if (queuedPromptsRef.current.length > 0 && !abortController.signal.aborted) {
+                        abortController.abort(new Error(queuedPromptAbortReason));
+                        break;
+                    }
+                }
+                else if (event.type === 'plan_update') {
+                    setWorkingStartedAt(Date.now());
+                    flushAssistantText();
+                    setFixedPlanItems(event.items.length > 0 ? event.items : undefined);
+                    setMessages(current => removeMatchingToolCall(finalizeStreamingMessages(current), event.callId));
+                }
+                else if (event.type === 'usage') {
+                    sawUsageEvent = true;
+                    setUsageTotals(current => addTokenUsage(current, event.usage));
+                    const remaining = contextRemainingPercentFromUsage(event.usage, activeContextWindowTokens);
+                    if (remaining !== undefined) {
+                        setContextRemainingPercent(remaining);
+                    }
+                    onTokenUsage?.(event.usage);
+                }
+                else if (event.type === 'done') {
+                    setWorkingStartedAt(undefined);
+                    flushAssistantText();
+                    setFixedPlanItems(current => (isCompletedPlan(current) ? undefined : current));
+                    if (event.usage && !sawUsageEvent) {
+                        const usage = event.usage;
+                        setUsageTotals(current => addTokenUsage(current, usage));
+                        const remaining = contextRemainingPercentFromUsage(usage, activeContextWindowTokens);
+                        if (remaining !== undefined) {
+                            setContextRemainingPercent(remaining);
+                        }
+                        onTokenUsage?.(usage);
+                    }
+                    setMessages(current => [
+                        ...current.map(message => (message.kind === 'assistant' ? { ...message, streaming: false } : message)),
+                        taskSummaryMessage(taskStartedAt, language),
+                    ]);
+                }
+                else if (event.type === 'error') {
+                    setWorkingStartedAt(undefined);
+                    flushAssistantText();
+                    const wasInterrupted = abortController.signal.aborted || event.message === 'Interrupted by user';
+                    if (!isQueuedPromptDispatchAbort(abortController.signal, event.message) && wasInterrupted) {
+                        setFixedPlanItems(undefined);
+                    }
+                    setMessages(current => {
+                        const finalizedMessages = finalizeStreamingMessages(current);
+                        if (isQueuedPromptDispatchAbort(abortController.signal, event.message)) {
+                            return finalizedMessages;
+                        }
+                        const terminalMessage = wasInterrupted
+                            ? interruptedMessage(language)
+                            : { kind: 'system', level: 'error', text: event.message };
+                        return [...finalizedMessages, terminalMessage, taskSummaryMessage(taskStartedAt, language)];
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            flushAssistantText();
+            const wasInterrupted = abortController.signal.aborted || message === 'Interrupted by user';
+            if (!isQueuedPromptDispatchAbort(abortController.signal, message) && wasInterrupted) {
+                setFixedPlanItems(undefined);
+            }
+            setMessages(current => {
+                const finalizedMessages = finalizeStreamingMessages(current);
+                if (isQueuedPromptDispatchAbort(abortController.signal, message)) {
+                    return finalizedMessages;
+                }
+                const terminalMessage = wasInterrupted
+                    ? interruptedMessage(language)
+                    : { kind: 'system', level: 'error', text: message };
+                return [...finalizedMessages, terminalMessage, taskSummaryMessage(taskStartedAt, language)];
+            });
+        }
+        finally {
+            flushAssistantText();
+            if (activeAbortController.current === abortController) {
+                activeAbortController.current = undefined;
+            }
+            setIsSubmitting(false);
+            setWorkingStartedAt(undefined);
+            const queuedText = consumeQueuedPromptText();
+            if (queuedText) {
+                setPendingQueuedDispatch(buildQueuedPromptDispatch(visibleUserInput, queuedText));
+            }
+        }
+    }, [
+        appendMessage,
+        chatRunner,
+        cwd,
+        exit,
+        input,
+        isSubmitting,
+        language,
+        mainModelAlias,
+        onTokenUsage,
+        permissionProfile,
+        consumeQueuedPromptText,
+        requestToolPermission,
+        requestExit,
+        responseStyle,
+        sessionId,
+        statusLineItems,
+        syntaxTheme,
+        updateQueuedPrompts,
+        usageTotals,
+    ]);
+    useEffect(() => {
+        if (!pendingQueuedDispatch || isSubmitting) {
+            return;
+        }
+        const queuedInput = pendingQueuedDispatch;
+        setPendingQueuedDispatch(undefined);
+        void submit(queuedInput);
+    }, [isSubmitting, pendingQueuedDispatch, submit]);
+    const updateModelPanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'model-panel', panel => panel.models)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'model-panel', delta, panel => panel.models));
+        return true;
+    }, [input, messages]);
+    const updateStylePanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'style-panel', panel => panel.styles)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'style-panel', delta, panel => panel.styles));
+        return true;
+    }, [input, messages]);
+    const updateSyntaxThemePanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'syntax-theme-panel', visibleSyntaxThemePanelItems)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'syntax-theme-panel', delta, visibleSyntaxThemePanelItems));
+        return true;
+    }, [input, messages]);
+    const updateLanguagePanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'language-panel', panel => panel.languages)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'language-panel', delta, panel => panel.languages));
+        return true;
+    }, [input, messages]);
+    const updatePermissionProfilePanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'permission-profile-panel', panel => panel.profiles)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'permission-profile-panel', delta, panel => panel.profiles));
+        return true;
+    }, [input, messages]);
+    const updatePermissionRequestSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, '', 'permission-request', panel => panel.options, { requireEmptyInput: false })) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'permission-request', delta, panel => panel.options));
+        return true;
+    }, [messages]);
+    const updateStatusLinePanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'statusline-panel', visibleStatusLinePanelItems)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'statusline-panel', delta, visibleStatusLinePanelItems));
+        return true;
+    }, [input, messages]);
+    const updateSkillsPanelSelection = useCallback((delta) => {
+        if (!hasActivePickerPanel(messages, input, 'skills-panel', skillsPanelItems)) {
+            return false;
+        }
+        setMessages(current => updatePickerPanelSelectionInMessages(current, 'skills-panel', delta, skillsPanelItems));
+        return true;
+    }, [input, messages]);
+    const navigateInputHistory = useCallback((delta) => {
+        if (inputHistory.length === 0) {
+            return false;
+        }
+        if (delta < 0) {
+            const nextCursor = historyCursor === undefined ? inputHistory.length - 1 : Math.max(0, historyCursor - 1);
+            if (historyCursor === undefined) {
+                setHistoryDraft(input);
+            }
+            const nextInput = inputHistory[nextCursor] ?? '';
+            setHistoryCursor(nextCursor);
+            setInput(nextInput);
+            setInputCursor(inputLength(nextInput));
+            setSelectedCommandIndex(0);
+            return true;
+        }
+        if (historyCursor === undefined) {
+            return false;
+        }
+        const nextCursor = historyCursor + 1;
+        if (nextCursor >= inputHistory.length) {
+            setHistoryCursor(undefined);
+            setInput(historyDraft);
+            setInputCursor(inputLength(historyDraft));
+            setHistoryDraft('');
+            setSelectedCommandIndex(0);
+            return true;
+        }
+        const nextInput = inputHistory[nextCursor] ?? '';
+        setHistoryCursor(nextCursor);
+        setInput(nextInput);
+        setInputCursor(inputLength(nextInput));
+        setSelectedCommandIndex(0);
+        return true;
+    }, [historyCursor, historyDraft, input, inputHistory]);
+    const resetInputHistoryNavigation = useCallback(() => {
+        setHistoryCursor(undefined);
+        setHistoryDraft('');
+    }, []);
+    const selectModelFromPanel = useCallback(() => {
+        const selection = selectedPickerPanelItem(messages, input, 'model-panel', panel => panel.models);
+        const selectedModel = selection?.item;
+        if (!selectedModel) {
+            return false;
+        }
+        setMainModelAlias(selectedModel.alias);
+        saveProjectMainModel(cwd, selectedModel.alias);
+        setMessages(current => {
+            const currentPanelIndex = findLastModelPanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'model-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({
+                kind: 'system',
+                level: 'info',
+                text: t(language, 'model.selected', { label: selectedModel.displayName }),
+            });
+            return next;
+        });
+        return true;
+    }, [cwd, input, language, messages]);
+    const selectStyleFromPanel = useCallback(() => {
+        const selection = selectedPickerPanelItem(messages, input, 'style-panel', panel => panel.styles);
+        const selectedStyle = selection?.item;
+        if (!selectedStyle) {
+            return false;
+        }
+        const styleId = selectedStyle.id;
+        setResponseStyle(styleId);
+        saveProjectResponseStyle(cwd, styleId);
+        setMessages(current => {
+            const currentPanelIndex = findLastStylePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'style-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({ kind: 'system', level: 'info', text: formatResponseStyleChanged(styleId, true, language) });
+            return next;
+        });
+        return true;
+    }, [cwd, input, language, messages]);
+    const selectSyntaxThemeFromPanel = useCallback(() => {
+        const selection = selectedPickerPanelItem(messages, input, 'syntax-theme-panel', visibleSyntaxThemePanelItems);
+        const selectedTheme = selection?.item;
+        if (!selectedTheme) {
+            return false;
+        }
+        setSyntaxTheme(selectedTheme.id);
+        saveProjectSyntaxTheme(cwd, selectedTheme.id);
+        setMessages(current => {
+            const currentPanelIndex = findLastSyntaxThemePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'syntax-theme-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({ kind: 'system', level: 'info', text: formatSyntaxThemeChanged(selectedTheme.id, true, language) });
+            return next;
+        });
+        return true;
+    }, [cwd, input, language, messages]);
+    const selectLanguageFromPanel = useCallback(() => {
+        const selection = selectedPickerPanelItem(messages, input, 'language-panel', panel => panel.languages);
+        const selectedLanguage = selection?.item;
+        if (!selectedLanguage) {
+            return false;
+        }
+        setLanguage(selectedLanguage.code);
+        saveProjectLanguage(cwd, selectedLanguage.code);
+        setMessages(current => {
+            const currentPanelIndex = findLastLanguagePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'language-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({
+                kind: 'system',
+                level: 'info',
+                text: t(selectedLanguage.code, 'language.saved', { label: languageLabel(selectedLanguage.code) }),
+            });
+            return next;
+        });
+        return true;
+    }, [cwd, input, messages]);
+    const selectPermissionProfileFromPanel = useCallback(() => {
+        const selection = selectedPickerPanelItem(messages, input, 'permission-profile-panel', panel => panel.profiles);
+        const selectedProfile = selection?.item;
+        if (!selectedProfile) {
+            return false;
+        }
+        setPermissionProfile(selectedProfile.id);
+        saveProjectPermissionProfile(cwd, selectedProfile.id);
+        setMessages(current => {
+            const currentPanelIndex = findLastPermissionProfilePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'permission-profile-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({ kind: 'system', level: 'info', text: formatPermissionProfileChanged(selectedProfile.id, language) });
+            return next;
+        });
+        return true;
+    }, [cwd, input, language, messages]);
+    const selectSkillsPanelAction = useCallback(() => {
+        const panelIndex = findLastSkillsPanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'skills-panel') {
+            return false;
+        }
+        if (panel.mode === 'actions') {
+            const selectedAction = panel.actions[normalizeIndex(panel.selectedIndex ?? 0, panel.actions.length)];
+            if (!selectedAction) {
+                return false;
+            }
+            setMessages(current => {
+                const currentPanelIndex = findLastSkillsPanelIndex(current);
+                const next = [...current];
+                if (next[currentPanelIndex]?.kind === 'skills-panel') {
+                    next[currentPanelIndex] = createSkillsListPanelMessage(cwd, language, selectedAction.id === 'toggle' ? 'toggle' : 'list');
+                }
+                return next;
+            });
+            return true;
+        }
+        if (panel.mode === 'toggle') {
+            const disabled = panel.skills.filter(skill => !skill.enabled).map(skill => skill.name);
+            saveProjectDisabledSkills(cwd, disabled);
+            setMessages(current => {
+                const currentPanelIndex = findLastSkillsPanelIndex(current);
+                const next = [...current];
+                if (next[currentPanelIndex]?.kind === 'skills-panel') {
+                    next.splice(currentPanelIndex, 1);
+                }
+                next.push({
+                    kind: 'system',
+                    level: 'info',
+                    text: t(language, 'skills.saved', { enabled: panel.skills.length - disabled.length, disabled: disabled.length }),
+                });
+                return next;
+            });
+            return true;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastSkillsPanelIndex(current);
+            const next = [...current];
+            if (next[currentPanelIndex]?.kind === 'skills-panel') {
+                next.splice(currentPanelIndex, 1);
+            }
+            next.push({ kind: 'system', level: 'info', text: t(language, 'skills.closed') });
+            return next;
+        });
+        return true;
+    }, [cwd, input, language, messages]);
+    const toggleSkillsPanelItem = useCallback(() => {
+        const panelIndex = findLastSkillsPanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'skills-panel' || panel.mode !== 'toggle') {
+            return false;
+        }
+        const selectedSkill = panel.skills[normalizeIndex(panel.selectedIndex ?? 0, panel.skills.length)];
+        if (!selectedSkill) {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastSkillsPanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'skills-panel' || currentPanel.mode !== 'toggle') {
+                return current;
+            }
+            const next = [...current];
+            next[currentPanelIndex] = {
+                ...currentPanel,
+                skills: currentPanel.skills.map(skill => (skill.name === selectedSkill.name ? { ...skill, enabled: !skill.enabled } : skill)),
+            };
+            return next;
+        });
+        return true;
+    }, [input, messages]);
+    const closeSkillsPanel = useCallback(() => {
+        const panelIndex = findLastSkillsPanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'skills-panel') {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastSkillsPanelIndex(current);
+            const next = [...current];
+            if (next[currentPanelIndex]?.kind === 'skills-panel') {
+                next.splice(currentPanelIndex, 1);
+            }
+            next.push({ kind: 'system', level: 'info', text: t(language, 'skills.closed') });
+            return next;
+        });
+        return true;
+    }, [input, language, messages]);
+    const resolvePermissionRequest = useCallback((optionId) => {
+        const panelIndex = findLastPermissionRequestIndex(messages);
+        const panel = messages[panelIndex];
+        const pending = pendingPermission.current;
+        if (panelIndex !== findLastPickerPanelIndex(messages) || panel?.kind !== 'permission-request' || !pending) {
+            return false;
+        }
+        const option = optionId ? panel.options.find(candidate => candidate.id === optionId) : panel.options[normalizeIndex(panel.selectedIndex ?? 0, panel.options.length)];
+        if (!option) {
+            return false;
+        }
+        pendingPermission.current = undefined;
+        if (option.id === 'allow-session' && option.rules?.length) {
+            sessionPermissionRules.current = addSessionPermissionRules(sessionPermissionRules.current, cwd, option.rules);
+            writeSessionPermissionRules(cwd, sessionId, sessionPermissionRules.current);
+        }
+        else if (option.id === 'allow-session' && option.prefixRule) {
+            sessionPermissionRules.current = addSessionPermissionRules(sessionPermissionRules.current, cwd, [
+                { kind: 'shell-prefix', prefix: option.prefixRule },
+            ]);
+            writeSessionPermissionRules(cwd, sessionId, sessionPermissionRules.current);
+        }
+        else if (option.id === 'allow-persist' && option.rules?.length) {
+            for (const rule of option.rules) {
+                saveProjectPermissionRule(cwd, rule);
+            }
+        }
+        else if (option.id === 'allow-persist' && option.prefixRule) {
+            saveProjectPermissionRule(cwd, option.prefixRule);
+        }
+        pending.resolve(option.id === 'deny'
+            ? { status: 'deny', reason: 'User denied the permission request.', requirements: pending.decision.requirements }
+            : {
+                status: 'allow',
+                reason: option.id === 'allow-session'
+                    ? 'User approved and allowed this rule for the current session.'
+                    : option.id === 'allow-persist'
+                        ? 'User approved and saved a persistent permission rule.'
+                        : 'User approved this tool call once.',
+                requirements: pending.decision.requirements,
+            });
+        setMessages(current => {
+            const currentPanelIndex = findLastPermissionRequestIndex(current);
+            const next = [...current];
+            if (currentPanelIndex >= 0 && next[currentPanelIndex]?.kind === 'permission-request') {
+                next.splice(currentPanelIndex, 1);
+            }
+            if (option.id === 'allow-session' || option.id === 'allow-persist') {
+                const rules = option.rules?.length ? option.rules : option.prefixRule ? [{ kind: 'shell-prefix', prefix: option.prefixRule }] : [];
+                if (rules.length > 0) {
+                    next.push({
+                        kind: 'system',
+                        level: 'info',
+                        text: t(language, option.id === 'allow-session' ? 'permission.savedRules' : 'permission.savedPersistentRules', {
+                            rule: formatPermissionRulesScope(rules, language),
+                        }),
+                    });
+                }
+            }
+            return next;
+        });
+        return true;
+    }, [cwd, language, messages, sessionId]);
+    const closeStatusLinePanel = useCallback(() => {
+        const panelIndex = findLastStatusLinePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'statusline-panel') {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastStatusLinePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'statusline-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({ kind: 'system', level: 'info', text: t(language, 'statusline.closed') });
+            return next;
+        });
+        return true;
+    }, [input, language, messages]);
+    const closeSyntaxThemePanel = useCallback(() => {
+        const panelIndex = findLastSyntaxThemePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'syntax-theme-panel') {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastSyntaxThemePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'syntax-theme-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({ kind: 'system', level: 'info', text: t(language, 'theme.closed') });
+            return next;
+        });
+        return true;
+    }, [input, language, messages]);
+    const updateSyntaxThemePanelQuery = useCallback((change) => {
+        const panelIndex = findLastSyntaxThemePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'syntax-theme-panel') {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastSyntaxThemePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'syntax-theme-panel') {
+                return current;
+            }
+            const query = change === 'backspace' ? currentPanel.query.slice(0, -1) : `${currentPanel.query}${change}`;
+            const next = [...current];
+            next[currentPanelIndex] = { ...currentPanel, query, selectedIndex: 0 };
+            return next;
+        });
+        return true;
+    }, [input, messages]);
+    const confirmStatusLinePanel = useCallback(() => {
+        const panelIndex = findLastStatusLinePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'statusline-panel') {
+            return false;
+        }
+        const enabledItems = panel.items.filter(item => item.enabled).map(item => item.id);
+        const nextItems = enabledItems.length > 0 ? enabledItems : defaultStatusLineItems;
+        const savedText = t(language, 'statusline.saved', { items: formatStatusLineItemLabels(nextItems, language) });
+        setStatusLineItems(nextItems);
+        saveProjectStatusLineItems(cwd, nextItems);
+        setMessages(current => {
+            const currentPanelIndex = findLastStatusLinePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'statusline-panel') {
+                return current;
+            }
+            const next = [...current];
+            next.splice(currentPanelIndex, 1);
+            next.push({ kind: 'system', level: 'info', text: savedText });
+            return next;
+        });
+        return true;
+    }, [cwd, input, language, messages]);
+    const toggleStatusLinePanelItem = useCallback(() => {
+        const panelIndex = findLastStatusLinePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'statusline-panel') {
+            return false;
+        }
+        const selectedItem = visibleStatusLinePanelItems(panel)[normalizeIndex(panel.selectedIndex ?? 0, visibleStatusLinePanelItems(panel).length)];
+        if (!selectedItem) {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastStatusLinePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'statusline-panel') {
+                return current;
+            }
+            const next = [...current];
+            next[currentPanelIndex] = {
+                ...currentPanel,
+                items: currentPanel.items.map(item => (item.id === selectedItem.id ? { ...item, enabled: !item.enabled } : item)),
+            };
+            return next;
+        });
+        return true;
+    }, [input, messages]);
+    const updateStatusLinePanelQuery = useCallback((change) => {
+        const panelIndex = findLastStatusLinePanelIndex(messages);
+        const panel = messages[panelIndex];
+        if (panelIndex !== findLastPickerPanelIndex(messages) || input.trim().length > 0 || panel?.kind !== 'statusline-panel') {
+            return false;
+        }
+        setMessages(current => {
+            const currentPanelIndex = findLastStatusLinePanelIndex(current);
+            const currentPanel = current[currentPanelIndex];
+            if (currentPanel?.kind !== 'statusline-panel') {
+                return current;
+            }
+            const query = change === 'backspace' ? currentPanel.query.slice(0, -1) : `${currentPanel.query}${change}`;
+            const next = [...current];
+            next[currentPanelIndex] = { ...currentPanel, query, selectedIndex: 0 };
+            return next;
+        });
+        return true;
+    }, [input, messages]);
+    useInput((rawInput, key) => {
+        const commandHintsForInput = visibleCommandHintsForInput(input, activeCommandHints);
+        if (key.ctrl && rawInput === 'c') {
+            if (input.length > 0) {
+                setInput('');
+                setInputCursor(0);
+                setSelectedCommandIndex(0);
+                resetInputHistoryNavigation();
+                return;
+            }
+            if (isSubmitting) {
+                if (pendingPermission.current) {
+                    resolvePermissionRequest('deny');
+                }
+                activeAbortController.current?.abort(new Error('Interrupted by user'));
+                return;
+            }
+            requestExit();
+            return;
+        }
+        if (key.escape && resolvePermissionRequest('deny')) {
+            return;
+        }
+        if (key.upArrow && updatePermissionRequestSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updatePermissionRequestSelection(1)) {
+            return;
+        }
+        if (key.return && resolvePermissionRequest()) {
+            return;
+        }
+        if (key.escape && isSubmitting) {
+            const queuedCurrentInput = queueCurrentInput();
+            if (queuedCurrentInput || queuedPromptsRef.current.length > 0) {
+                activeAbortController.current?.abort(new Error(queuedPromptAbortReason));
+                return;
+            }
+            activeAbortController.current?.abort(new Error('Interrupted by user'));
+            return;
+        }
+        if (key.escape && closeStatusLinePanel()) {
+            return;
+        }
+        if (key.escape && closeSyntaxThemePanel()) {
+            return;
+        }
+        if (key.escape && closeSkillsPanel()) {
+            return;
+        }
+        if (key.upArrow && updateStatusLinePanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updateStatusLinePanelSelection(1)) {
+            return;
+        }
+        if (key.upArrow && updateSyntaxThemePanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updateSyntaxThemePanelSelection(1)) {
+            return;
+        }
+        if (key.upArrow && updateSkillsPanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updateSkillsPanelSelection(1)) {
+            return;
+        }
+        if (rawInput === ' ' && toggleStatusLinePanelItem()) {
+            return;
+        }
+        if (rawInput === ' ' && toggleSkillsPanelItem()) {
+            return;
+        }
+        if (key.return && confirmStatusLinePanel()) {
+            return;
+        }
+        if (key.return && selectSyntaxThemeFromPanel()) {
+            return;
+        }
+        if ((key.backspace || key.delete) && updateStatusLinePanelQuery('backspace')) {
+            return;
+        }
+        if ((key.backspace || key.delete) && updateSyntaxThemePanelQuery('backspace')) {
+            return;
+        }
+        if (isPrintableInput(rawInput) && updateStatusLinePanelQuery(rawInput)) {
+            return;
+        }
+        if (isPrintableInput(rawInput) && updateSyntaxThemePanelQuery(rawInput)) {
+            return;
+        }
+        if (key.ctrl && rawInput === 'u') {
+            setInput('');
+            setInputCursor(0);
+            setSelectedCommandIndex(0);
+            resetInputHistoryNavigation();
+            return;
+        }
+        if (key.ctrl && rawInput === 'w') {
+            const next = trimOneWordBeforeCursor(input, inputCursor);
+            setInput(next.value);
+            setInputCursor(next.cursor);
+            resetInputHistoryNavigation();
+            return;
+        }
+        if (key.leftArrow) {
+            setInputCursor(current => Math.max(0, current - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setInputCursor(current => Math.min(inputLength(input), current + 1));
+            return;
+        }
+        if (key.upArrow && commandHintsForInput.length > 0) {
+            setSelectedCommandIndex(current => normalizeIndex(current - 1, commandHintsForInput.length));
+            return;
+        }
+        if (key.downArrow && commandHintsForInput.length > 0) {
+            setSelectedCommandIndex(current => normalizeIndex(current + 1, commandHintsForInput.length));
+            return;
+        }
+        if (key.upArrow && updateModelPanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updateModelPanelSelection(1)) {
+            return;
+        }
+        if (key.upArrow && updateStylePanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updateStylePanelSelection(1)) {
+            return;
+        }
+        if (key.upArrow && updateLanguagePanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updateLanguagePanelSelection(1)) {
+            return;
+        }
+        if (key.upArrow && updatePermissionProfilePanelSelection(-1)) {
+            return;
+        }
+        if (key.downArrow && updatePermissionProfilePanelSelection(1)) {
+            return;
+        }
+        if (key.upArrow && navigateInputHistory(-1)) {
+            return;
+        }
+        if (key.downArrow && navigateInputHistory(1)) {
+            return;
+        }
+        if (key.tab || rawInput === '\t') {
+            const selectedCommand = selectedCommandForInput(input, activeCommandHints, selectedCommandIndex);
+            if (selectedCommand) {
+                const nextInput = `${selectedCommand.name} `;
+                setInput(nextInput);
+                setInputCursor(inputLength(nextInput));
+                setSelectedCommandIndex(0);
+            }
+            return;
+        }
+        if (key.return) {
+            if (isSubmitting && queueCurrentInput()) {
+                return;
+            }
+            const selectedCommand = selectedCommandForInput(input, activeCommandHints, selectedCommandIndex);
+            if (selectedCommand) {
+                void submit(selectedCommand.name);
+                return;
+            }
+            if (selectModelFromPanel()) {
+                return;
+            }
+            if (selectStyleFromPanel()) {
+                return;
+            }
+            if (selectSyntaxThemeFromPanel()) {
+                return;
+            }
+            if (selectLanguageFromPanel()) {
+                return;
+            }
+            if (selectPermissionProfileFromPanel()) {
+                return;
+            }
+            if (selectSkillsPanelAction()) {
+                return;
+            }
+            void submit();
+            return;
+        }
+        if (key.backspace) {
+            const next = deleteInputBeforeCursor(input, inputCursor);
+            setInput(next.value);
+            setInputCursor(next.cursor);
+            setSelectedCommandIndex(0);
+            resetInputHistoryNavigation();
+            return;
+        }
+        if (key.delete) {
+            const next = deleteInputAtCursor(input, inputCursor);
+            setInput(next.value);
+            setInputCursor(next.cursor);
+            setSelectedCommandIndex(0);
+            resetInputHistoryNavigation();
+            return;
+        }
+        if (isPrintableInput(rawInput)) {
+            if (rawInput === '$' && input.length === 0 && !isSubmitting) {
+                appendMessage(createSkillsListPanelMessage(cwd, language, 'list'));
+                return;
+            }
+            const next = insertInputText(input, inputCursor, rawInput);
+            setInput(next.value);
+            setInputCursor(next.cursor);
+            setSelectedCommandIndex(0);
+            resetInputHistoryNavigation();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { status: status, width: viewportWidth }), _jsx(MessageList, { messages: mainMessages, width: viewportWidth, emptyText: fixedPlanItems && fixedPlanItems.length > 0 ? '' : t(language, 'messages.empty'), progress: isSubmitting && workingStartedAt !== undefined
+                    ? { startedAt: workingStartedAt, label: progressLabelOverride ?? t(language, 'thinking.label'), interruptText: t(language, 'working.interrupt') }
+                    : undefined, syntaxTheme: syntaxTheme, language: language, slashCommandHints: commandHints }), queuedPrompts.length > 0 ? _jsx(QueuedPromptList, { prompts: queuedPrompts, language: language }) : null, fixedPlanItems && fixedPlanItems.length > 0 ? (_jsx(PlanMessage, { items: fixedPlanItems, marginTop: mainMessages.length > 0 ? 1 : 0, width: viewportWidth })) : null, bottomPanelMessage ? (_jsx(Box, { marginTop: fixedPlanItems && fixedPlanItems.length > 0 ? 1 : mainMessages.length > 0 ? 1 : 0, children: _jsx(MessageList, { messages: [bottomPanelMessage], width: viewportWidth, emptyText: "", syntaxTheme: syntaxTheme, language: language, slashCommandHints: commandHints }) })) : null, isStatusLinePanelOpen || isSyntaxThemePanelOpen || isPermissionRequestOpen || isSkillsPanelOpen ? null : (_jsx(Box, { marginTop: fixedPlanItems && fixedPlanItems.length > 0 ? 1 : 0, children: _jsx(PromptBox, { input: prompt, width: viewportWidth }) })), _jsx(StatusLine, { status: status, width: viewportWidth })] }));
+}
+function visibleCommandHintsForInput(input, commands) {
+    if (!input.startsWith('/') || /\s/.test(input)) {
+        return [];
+    }
+    const query = input.trim();
+    return commands.filter(command => query === '/' || command.name.startsWith(query));
+}
+function loadEnabledSkillCount(cwd, disabled) {
+    return loadSkillIndex(disabled ? { cwd, disabled } : { cwd }).skills.filter(skill => skill.enabled).length;
+}
+function selectedCommandForInput(input, commands, selectedIndex) {
+    const commandsForInput = visibleCommandHintsForInput(input, commands);
+    if (commandsForInput.length === 0) {
+        return undefined;
+    }
+    return commandsForInput[normalizeIndex(selectedIndex, commandsForInput.length)];
+}
+function QueuedPromptList({ prompts, language }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: remiDarkTheme.text, children: ["\u2022 ", t(language, 'queue.title')] }), _jsxs(Text, { color: remiDarkTheme.muted, children: [" (", t(language, 'queue.hint'), ")"] })] }), prompts.map(prompt => (_jsxs(Box, { children: [_jsx(Text, { color: remiDarkTheme.muted, children: "  \u21B3 " }), _jsx(Text, { color: remiDarkTheme.muted, children: prompt.text })] }, prompt.id)))] }));
+}
+function normalizeIndex(index, length) {
+    if (length <= 0) {
+        return 0;
+    }
+    return ((index % length) + length) % length;
+}
+function hasActivePickerPanel(messages, input, kind, getItems, options = {}) {
+    if ((options.requireEmptyInput ?? true) && input.trim().length > 0) {
+        return false;
+    }
+    const panelIndex = findLastPanelIndexByKind(messages, kind);
+    const panel = messages[panelIndex];
+    return panelIndex === findLastPickerPanelIndex(messages) && panel?.kind === kind && getItems(panel).length > 0;
+}
+function selectedPickerPanelItem(messages, input, kind, getItems, options = {}) {
+    if (!hasActivePickerPanel(messages, input, kind, getItems, options)) {
+        return undefined;
+    }
+    const panelIndex = findLastPanelIndexByKind(messages, kind);
+    const panel = messages[panelIndex];
+    const items = getItems(panel);
+    const index = normalizeIndex(panel.selectedIndex ?? 0, items.length);
+    const item = items[index];
+    return item === undefined ? undefined : { panel, item, index };
+}
+function updatePickerPanelSelectionInMessages(messages, kind, delta, getItems) {
+    const panelIndex = findLastPanelIndexByKind(messages, kind);
+    const panel = messages[panelIndex];
+    if (panelIndex !== findLastPickerPanelIndex(messages) || panel?.kind !== kind) {
+        return messages;
+    }
+    const items = getItems(panel);
+    if (items.length === 0) {
+        return messages;
+    }
+    const next = [...messages];
+    next[panelIndex] = {
+        ...panel,
+        selectedIndex: normalizeIndex((panel.selectedIndex ?? 0) + delta, items.length),
+    };
+    return next;
+}
+function findLastPanelIndexByKind(messages, kind) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        if (messages[index]?.kind === kind) {
+            return index;
+        }
+    }
+    return -1;
+}
+function findActiveBottomPanelIndex(messages) {
+    const panelIndex = findLastPickerPanelIndex(messages);
+    const message = messages[panelIndex];
+    if (message?.kind === 'permission-request' ||
+        message?.kind === 'statusline-panel' ||
+        message?.kind === 'syntax-theme-panel' ||
+        message?.kind === 'skills-panel') {
+        return panelIndex;
+    }
+    return -1;
+}
+function isCompletedPlan(items) {
+    return Boolean(items && items.length > 0 && items.every(item => item.status === 'completed'));
+}
+function appendAssistantDelta(messages, text) {
+    const next = [...messages];
+    const index = next.length - 1;
+    const currentMessage = next[index];
+    if (currentMessage?.kind === 'assistant') {
+        next[index] = {
+            ...currentMessage,
+            text: currentMessage.text + text,
+            streaming: true,
+        };
+        return next;
+    }
+    return [...next, { kind: 'assistant', text, streaming: true }];
+}
+function finalizeStreamingMessages(messages) {
+    return messages
+        .filter(message => !(message.kind === 'assistant' && message.text.length === 0))
+        .map(message => (message.kind === 'assistant' ? { ...message, streaming: false } : message));
+}
+function removeMatchingToolCall(messages, callId) {
+    const index = findLastMatchingToolCallIndex(messages, callId);
+    if (index < 0) {
+        return messages;
+    }
+    const next = [...messages];
+    next.splice(index, 1);
+    return next;
+}
+function replaceToolCallWithResult(messages, result) {
+    const index = findLastMatchingToolCallIndex(messages, result.callId);
+    if (index < 0) {
+        return [...messages, result];
+    }
+    const current = messages[index];
+    const next = [...messages];
+    next[index] = {
+        ...result,
+        summary: result.summary || (current?.kind === 'tool-call' ? current.summary : ''),
+        ...(current?.kind === 'tool-call' ? { inputSummary: current.summary } : {}),
+        ...(result.detail ? { detail: result.detail } : {}),
+    };
+    return next;
+}
+function findLastMatchingToolCallIndex(messages, callId) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message?.kind !== 'tool-call') {
+            continue;
+        }
+        if (!callId || message.callId === callId) {
+            return index;
+        }
+    }
+    return -1;
+}
+function taskSummaryMessage(startedAt, language) {
+    return { kind: 'task-summary', durationMs: Date.now() - startedAt, label: t(language, 'task.worked', { duration: '' }).trim() };
+}
+function interruptedMessage(language) {
+    return { kind: 'interrupted', text: t(language, 'interrupt.message') };
+}
+function permissionRequestMessage(requestId, request, decision, language) {
+    const fileAction = formatPermissionFileAction(request, language);
+    const options = [
+        {
+            id: 'allow-once',
+            label: t(language, 'permission.request.once'),
+        },
+    ];
+    const explicitSuggestedRules = request.suggestedRules?.length
+        ? request.suggestedRules
+        : request.command?.suggestedRules?.length
+            ? request.command.suggestedRules
+            : request.command?.suggestedRule
+                ? [request.command.suggestedRule]
+                : request.command?.suggestedPrefix
+                    ? [{ kind: 'shell-prefix', prefix: request.command.suggestedPrefix }]
+                    : [];
+    const fallbackSuggestedRules = explicitSuggestedRules.length > 0 ? [] : fallbackFilesystemPermissionRules(request);
+    const suggestedRules = explicitSuggestedRules.length > 0 ? explicitSuggestedRules : fallbackSuggestedRules;
+    const canOfferRule = ((request.canPersist ?? request.command?.canPersist ?? false) || fallbackSuggestedRules.length > 0) && suggestedRules.length > 0;
+    const filesystemRulesOnly = suggestedRules.length > 0 && suggestedRules.every(rule => rule.kind === 'filesystem-write-root');
+    const shellRulesOnly = suggestedRules.length > 0 && suggestedRules.every(rule => rule.kind === 'shell-prefix');
+    if (canOfferRule && filesystemRulesOnly) {
+        const ruleLabel = formatPermissionRulesScope(suggestedRules, language);
+        options.push({
+            id: 'allow-session',
+            label: t(language, 'permission.request.sessionRule', { rule: ruleLabel }),
+            rules: suggestedRules,
+        });
+    }
+    else if (canOfferRule && shellRulesOnly) {
+        const ruleLabel = formatPermissionRulesScope(suggestedRules, language);
+        const firstShellRule = suggestedRules.find(rule => rule.kind === 'shell-prefix');
+        const prefixRule = request.command?.suggestedPrefix ?? firstShellRule?.prefix;
+        options.push({
+            id: 'allow-persist',
+            label: t(language, 'permission.request.persistRule', { rule: ruleLabel }),
+            rules: suggestedRules,
+            ...(prefixRule ? { prefixRule } : {}),
+        });
+    }
+    options.push({
+        id: 'deny',
+        label: t(language, 'permission.request.deny'),
+    });
+    return {
+        kind: 'permission-request',
+        requestId,
+        title: t(language, fileAction ? 'permission.request.title.action' : 'permission.request.title'),
+        reason: t(language, 'permission.request.reason', { reason: decision.reason }),
+        toolName: request.toolName,
+        summary: request.inputSummary,
+        ...(request.targetPath ? { targetPath: request.targetPath } : {}),
+        ...(fileAction ? { action: fileAction.action, actionDetail: fileAction.detail } : {}),
+        ...(request.command?.commandLine ? { command: request.command.commandLine } : {}),
+        ...(request.command?.capability
+            ? {
+                capability: {
+                    id: request.command.capability.id,
+                    risk: request.command.capability.risk,
+                    ...(request.command.capability.platform ? { platform: request.command.capability.platform } : {}),
+                    ...(request.command.capability.target ? { target: request.command.capability.target } : {}),
+                    ...(request.command.capability.packageManager ? { packageManager: request.command.capability.packageManager } : {}),
+                    ...(request.command.capability.requiresAdmin !== undefined ? { requiresAdmin: request.command.capability.requiresAdmin } : {}),
+                },
+            }
+            : {}),
+        selectedIndex: 0,
+        options,
+        helpText: t(language, 'permission.request.help'),
+    };
+}
+function fallbackFilesystemPermissionRules(request) {
+    const operations = permissionFilesystemOperationsForTool(request.toolName);
+    const targetPath = request.targetPath ?? parsePermissionRequestPath(request.inputSummary);
+    if (operations.length === 0 || !targetPath) {
+        return [];
+    }
+    const root = fallbackFilesystemPermissionRoot(targetPath, request.cwd, request.toolName);
+    return root ? [{ kind: 'filesystem-write-root', root, operations }] : [];
+}
+function permissionFilesystemOperationForTool(toolName) {
+    if (toolName === 'create_directory') {
+        return 'create';
+    }
+    if (toolName === 'write_file') {
+        return 'write';
+    }
+    if (toolName === 'edit_file') {
+        return 'edit';
+    }
+    if (toolName === 'delete_file') {
+        return 'delete';
+    }
+    if (toolName === 'delete_directory') {
+        return 'delete';
+    }
+    return undefined;
+}
+function permissionFilesystemOperationsForTool(toolName) {
+    const operation = permissionFilesystemOperationForTool(toolName);
+    if (!operation) {
+        return [];
+    }
+    if (operation === 'write' || operation === 'edit') {
+        return ['write', 'edit'];
+    }
+    return [operation];
+}
+function fallbackFilesystemPermissionRoot(targetPath, cwd, toolName) {
+    const absolutePath = isAbsolute(targetPath) ? resolve(targetPath) : resolve(cwd, targetPath);
+    const resolvedCwd = resolve(cwd);
+    if (isPathInsideOrEqual(absolutePath, resolvedCwd)) {
+        return resolvedCwd;
+    }
+    const desktop = resolve(homedir(), 'Desktop');
+    if (isPathInsideOrEqual(absolutePath, desktop)) {
+        const rel = relative(desktop, absolutePath);
+        const [project] = rel.split(sep).filter(Boolean);
+        if (project) {
+            return resolve(desktop, project);
+        }
+    }
+    return dirname(absolutePath);
+}
+function isPathInsideOrEqual(target, root) {
+    const rel = relative(root, target);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+function parsePermissionRequestPath(inputSummary) {
+    try {
+        const parsed = JSON.parse(inputSummary);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return undefined;
+        }
+        const path = parsed['path'];
+        return typeof path === 'string' && path.trim().length > 0 ? path : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function visibleStatusLinePanelItems(message) {
+    const query = message.query.trim().toLowerCase();
+    if (!query) {
+        return message.items;
+    }
+    return message.items.filter(item => `${item.label} ${item.description}`.toLowerCase().includes(query));
+}
+function statusLineItemsFromPanel(message) {
+    return message.items.filter(item => item.enabled).map(item => item.id);
+}
+function visibleSyntaxThemePanelItems(message) {
+    const query = message.query.trim().toLowerCase();
+    if (!query) {
+        return message.themes;
+    }
+    return message.themes.filter(theme => `${theme.id} ${theme.label} ${theme.description}`.toLowerCase().includes(query));
+}
+function skillsPanelItems(message) {
+    return message.mode === 'actions' ? message.actions : message.skills;
+}
+function formatStatusLineItemLabels(items, language) {
+    const labels = new Map(getStatusLineCatalog(language).map(item => [item.id, item.label]));
+    return items.map(item => labels.get(item) ?? item).join(', ');
+}
+function findLastModelPanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'model-panel');
+}
+function findLastStylePanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'style-panel');
+}
+function findLastSyntaxThemePanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'syntax-theme-panel');
+}
+function findLastLanguagePanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'language-panel');
+}
+function findLastPermissionProfilePanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'permission-profile-panel');
+}
+function findLastPermissionRequestIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'permission-request');
+}
+function findLastStatusLinePanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'statusline-panel');
+}
+function findLastSkillsPanelIndex(messages) {
+    return findLastPanelIndexByKind(messages, 'skills-panel');
+}
+function findLastPickerPanelIndex(messages) {
+    return Math.max(findLastModelPanelIndex(messages), findLastStylePanelIndex(messages), findLastSyntaxThemePanelIndex(messages), findLastLanguagePanelIndex(messages), findLastPermissionProfilePanelIndex(messages), findLastPermissionRequestIndex(messages), findLastStatusLinePanelIndex(messages), findLastSkillsPanelIndex(messages));
+}