@blackbox_ai/blackbox-cli 0.0.9 → 0.8.1

package/dist/src/ui/App.js

@@ -8,19 +8,23 @@ import { useCallback, useEffect, useMemo, useState, useRef } from 'react';
 import { Box, measureElement, Static, Text, useStdin, useStdout, } from 'ink';
 import { StreamingState, MessageType, ToolCallStatus, } from './types.js';
 import { useTerminalSize } from './hooks/useTerminalSize.js';
-import { useGeminiStream } from './hooks/useGeminiStream.js';
+import { useAdaptiveStream } from './hooks/useAdaptiveStream.js';
 import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
+import { useTodoList } from './hooks/useTodoList.js';
 import { useThemeCommand } from './hooks/useThemeCommand.js';
 import { useAuthCommand } from './hooks/useAuthCommand.js';
+import { useReleasesDialog } from './hooks/useReleasesDialog.js';
 import { useBlackboxAuth } from './hooks/useBlackboxAuth.js';
 import { useFolderTrust } from './hooks/useFolderTrust.js';
 import { useEditorSettings } from './hooks/useEditorSettings.js';
 import { useQuitConfirmation } from './hooks/useQuitConfirmation.js';
 import { useWelcomeBack } from './hooks/useWelcomeBack.js';
 import { useDialogClose } from './hooks/useDialogClose.js';
+import { useDialogCloseAnimation } from './hooks/useDialogCloseAnimation.js';
 import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
 import { useSubagentCreateDialog } from './hooks/useSubagentCreateDialog.js';
 import { useAgentsManagerDialog } from './hooks/useAgentsManagerDialog.js';
+import { useMultiAgentConfigCommand } from './hooks/useMultiAgentConfigCommand.js';
 import { useAutoAcceptIndicator } from './hooks/useAutoAcceptIndicator.js';
 import { useMessageQueue } from './hooks/useMessageQueue.js';
 import { useConsoleMessages } from './hooks/useConsoleMessages.js';
@@ -31,6 +35,7 @@ import { ShellModeIndicator } from './components/ShellModeIndicator.js';
 import { InputPrompt } from './components/InputPrompt.js';
 import { Footer } from './components/Footer.js';
 import { ThemeDialog } from './components/ThemeDialog.js';
+import { ReleaseNotesDialog } from './components/ReleaseNotesDialog.js';
 import { AuthDialog } from './components/AuthDialog.js';
 import { AuthInProgress } from './components/AuthInProgress.js';
 import { BlackboxOAuthProgress } from './components/BlackboxOAuthProgress.js';
@@ -42,8 +47,10 @@ import { RadioButtonSelect } from './components/shared/RadioButtonSelect.js';
 import { ModelSelectionDialog } from './components/ModelSelectionDialog.js';
 import { ModelSwitchDialog, } from './components/ModelSwitchDialog.js';
 import { getOpenAIAvailableModelFromEnv, getFilteredBlackboxModels, } from './models/availableModels.js';
+import { HistoryBrowserDialog } from './components/HistoryBrowserDialog.js';
 import { processVisionSwitchOutcome } from './hooks/useVisionAutoSwitch.js';
 import { AgentCreationWizard, AgentsManagerDialog, } from './components/subagents/index.js';
+import { MultiAgentConfigDialog } from './components/multiagent/MultiAgentConfigDialog.js';
 import { Colors } from './colors.js';
 import { loadHierarchicalGeminiMemory } from '../config/config.js';
 import { SettingScope } from '../config/settings.js';
@@ -56,7 +63,6 @@ import { ContextSummaryDisplay } from './components/ContextSummaryDisplay.js';
 import { useHistory } from './hooks/useHistoryManager.js';
 import process from 'node:process';
 import { ApprovalMode, getAllGeminiMdFilenames, isEditorAvailable, getErrorMessage, AuthType, logFlashFallback, FlashFallbackEvent, ideContext, isProQuotaExceededError, isGenericQuotaExceededError, UserTierId, } from '@blackbox_ai/blackbox-cli-core';
-import { IdeIntegrationNudge } from './IdeIntegrationNudge.js';
 import { validateAuthMethod } from '../config/auth.js';
 import { useLogger } from './hooks/useLogger.js';
 import { StreamingContext } from './contexts/StreamingContext.js';
@@ -79,12 +85,16 @@ import { ShowMoreLines } from './components/ShowMoreLines.js';
 import { PrivacyNotice } from './privacy/PrivacyNotice.js';
 import { useSettingsCommand } from './hooks/useSettingsCommand.js';
 import { SettingsDialog } from './components/SettingsDialog.js';
-import { setUpdateHandler } from '../utils/handleAutoUpdate.js';
+import { ExtensionsDialog } from './components/ExtensionsDialog.js';
+import { useExtensionsDialog } from './hooks/useExtensionsDialog.js';
 import { appEvents, AppEvent } from '../utils/events.js';
 import { isNarrowWidth } from './utils/isNarrowWidth.js';
 import { useWorkspaceMigration } from './hooks/useWorkspaceMigration.js';
 import { WorkspaceMigrationDialog } from './components/WorkspaceMigrationDialog.js';
 import { WelcomeBackDialog } from './components/WelcomeBackDialog.js';
+import { TodoListDialog } from './components/TodoListDialog.js';
+import { ConfigureUI } from '../commands/configure/ConfigureUI.js';
+import { VoiceConfigDialog } from './components/VoiceConfigDialog.js';
 // Maximum number of queued messages to display in UI to prevent performance issues
 const MAX_DISPLAYED_QUEUED_MESSAGES = 3;
 function isToolExecuting(pendingHistoryItems) {
@@ -100,26 +110,36 @@ export const AppWrapper = (props) => {
     const nodeMajorVersion = parseInt(process.versions.node.split('.')[0], 10);
     return (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyProtocolStatus.enabled, pasteWorkaround: process.platform === 'win32' || nodeMajorVersion < 20, config: props.config, debugKeystrokeLogging: props.settings.merged.general?.debugKeystrokeLogging, children: _jsx(SessionStatsProvider, { children: _jsx(VimModeProvider, { settings: props.settings, children: _jsx(App, { ...props }) }) }) }));
 };
-const App = ({ config, settings, startupWarnings = [], version }) => {
+// Wrapper component to add animation to ShellConfirmationDialog
+const ShellConfirmationDialogWithAnimation = ({ request }) => {
+    // Animation hook for shell confirmation dialog
+    const shellDialogAnimation = useDialogCloseAnimation(() => {
+        // Close handler - will be called after animation
+        // The original onConfirm already handles closing via setShellConfirmationRequest(null)
+    });
+    // Wrap the onConfirm to trigger animation before calling original
+    const wrappedRequest = {
+        ...request,
+        onConfirm: (outcome, approvedCommands) => {
+            // Start animation first
+            shellDialogAnimation.startClosing();
+            // Then call original handler (which closes the dialog)
+            request.onConfirm(outcome, approvedCommands);
+        },
+    };
+    return (_jsx(ShellConfirmationDialog, { request: wrappedRequest, isClosing: shellDialogAnimation.isClosing }));
+};
+const App = ({ config, settings, startupWarnings = [], version, initialSlashCommand, }) => {
     const isFocused = useFocus();
     useBracketedPaste();
-    const [updateInfo, setUpdateInfo] = useState(null);
+    const [updateInfo, _setUpdateInfo] = useState(null);
     const { stdout } = useStdout();
     const nightly = version.includes('nightly');
     const { history, addItem, clearItems, loadHistory } = useHistory();
-    const [idePromptAnswered, setIdePromptAnswered] = useState(false);
-    const currentIDE = config.getIdeClient().getCurrentIde();
-    useEffect(() => {
-        registerCleanup(() => config.getIdeClient().disconnect());
-    }, [config]);
-    const shouldShowIdePrompt = currentIDE &&
-        !config.getIdeMode() &&
-        !settings.merged.ide?.hasSeenNudge &&
-        !idePromptAnswered;
-    useEffect(() => {
-        const cleanup = setUpdateHandler(addItem, setUpdateInfo);
-        return cleanup;
-    }, [addItem]);
+    // const currentIDE = config.getIdeClient().getCurrentIde();
+    // useEffect(() => {
+    //   registerCleanup(() => config.getIdeClient().disconnect());
+    // }, [config]);
     const { consoleMessages, handleNewMessage, clearConsoleMessages: clearConsoleMessagesState, } = useConsoleMessages();
     useEffect(() => {
         const consolePatcher = new ConsolePatcher({
@@ -160,6 +180,10 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     const [ideContextState, setIdeContextState] = useState();
     const [showEscapePrompt, setShowEscapePrompt] = useState(false);
     const [isProcessing, setIsProcessing] = useState(false);
+    const [showTodoListDialog, setShowTodoListDialog] = useState(false);
+    const [isVoiceConfigDialogOpen, setIsVoiceConfigDialogOpen] = useState(false);
+    // Releases dialog hook
+    const { isReleasesDialogOpen, openReleasesDialog, closeReleasesDialog, releasesVersions, isReleasesLoading, } = useReleasesDialog();
     const { showWorkspaceMigrationDialog, workspaceExtensions, onWorkspaceMigrationDialogOpen, onWorkspaceMigrationDialogClose, } = useWorkspaceMigration(settings);
     // Model selection dialog states
     const [isModelSelectionDialogOpen, setIsModelSelectionDialogOpen] = useState(false);
@@ -193,6 +217,74 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     const openPrivacyNotice = useCallback(() => {
         setShowPrivacyNotice(true);
     }, []);
+    const [isDbConfigureDialogOpen, setIsDbConfigureDialogOpen] = useState(false);
+    const openDbConfigureDialog = useCallback(() => {
+        setIsDbConfigureDialogOpen(true);
+    }, []);
+    const closeDbConfigureDialog = useCallback(() => {
+        setIsDbConfigureDialogOpen(false);
+    }, []);
+    // Cancel DB configure - closes dialog AND resolves the pending promise with null
+    const cancelDbConfigure = useCallback(() => {
+        setIsDbConfigureDialogOpen(false);
+        // Resolve the pending promise with null to signal cancellation
+        dbConfigureRequestRef.current?.resolve(null);
+        dbConfigureRequestRef.current = null;
+    }, []);
+    const inferDbTypeFromUri = useCallback((connectionUri) => {
+        const trimmed = connectionUri.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            const url = new URL(trimmed);
+            const protocol = url.protocol.replace(':', '').toLowerCase();
+            if (protocol === 'postgres' || protocol === 'postgresql')
+                return 'postgres';
+            if (protocol === 'mysql')
+                return 'mysql';
+            if (protocol === 'mongodb' || protocol === 'mongodb+srv')
+                return 'mongodb';
+            if (protocol === 'redis' || protocol === 'rediss')
+                return 'redis';
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }, []);
+    const dbConfigureRequestRef = useRef(null);
+    const openDbConfigureDialogAsync = useCallback(() => {
+        if (dbConfigureRequestRef.current) {
+            return dbConfigureRequestRef.current.promise;
+        }
+        let resolve;
+        const promise = new Promise((res) => {
+            resolve = res;
+        });
+        dbConfigureRequestRef.current = { promise, resolve };
+        openDbConfigureDialog();
+        return promise;
+    }, [openDbConfigureDialog]);
+    const completeDbConfigure = useCallback(() => {
+        closeDbConfigureDialog();
+        const connectionUri = (process.env['DB_CONNECTION_URI'] || '').trim();
+        const dbType = connectionUri ? inferDbTypeFromUri(connectionUri) : undefined;
+        const result = connectionUri && dbType ? { dbType, connectionUri } : null;
+        dbConfigureRequestRef.current?.resolve(result);
+        dbConfigureRequestRef.current = null;
+        addItem({
+            type: MessageType.INFO,
+            text: '✓ DB connection saved in env variable DB_CONNECTION_URI and not passed to the agent directly.',
+        }, Date.now());
+    }, [addItem, closeDbConfigureDialog, inferDbTypeFromUri]);
+    useEffect(() => {
+        config.setInteractiveUiActions({
+            sqlDbConfigure: openDbConfigureDialogAsync,
+        });
+        return () => {
+            config.setInteractiveUiActions(undefined);
+        };
+    }, [config, openDbConfigureDialogAsync]);
     const handleEscapePromptChange = useCallback((showPrompt) => {
         setShowEscapePrompt(showPrompt);
     }, []);
@@ -200,18 +292,87 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     const errorCount = useMemo(() => consoleMessages
         .filter((msg) => msg.type === 'error')
         .reduce((total, msg) => total + msg.count, 0), [consoleMessages]);
-    const { isThemeDialogOpen, openThemeDialog, handleThemeSelect, handleThemeHighlight, } = useThemeCommand(settings, setThemeError, addItem);
-    const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } = useSettingsCommand();
+    const { isThemeDialogOpen, openThemeDialog, handleThemeSelect: handleThemeSelectOriginal, handleThemeHighlight, } = useThemeCommand(settings, setThemeError, addItem);
+    // Animation hook for theme dialog
+    const themeDialogAnimation = useDialogCloseAnimation(() => {
+        // Close handler - will be called after animation
+        // For ESC, we call the original with undefined
+        // For selections, the work is already done, so we just need to ensure dialog closes
+        // But the original handler already closes, so this is mainly for ESC case
+    });
+    // Wrapped handler that triggers animation before closing
+    const handleThemeSelect = useCallback((themeName, scope) => {
+        // Start animation first
+        themeDialogAnimation.startClosing();
+        // Then do the work (original handler does work and closes)
+        // The close happens immediately, but isClosing state will be true briefly
+        // showing the dimmed appearance during the transition
+        handleThemeSelectOriginal(themeName, scope);
+    }, [handleThemeSelectOriginal, themeDialogAnimation]);
+    const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog: closeSettingsDialogOriginal } = useSettingsCommand();
+    const { isExtensionsDialogOpen, openExtensionsDialog, closeExtensionsDialog: closeExtensionsDialogOriginal } = useExtensionsDialog();
+    // Animation hook for settings dialog
+    const settingsDialogAnimation = useDialogCloseAnimation(() => {
+        closeSettingsDialogOriginal();
+    });
+    // Animation hook for extensions dialog
+    const extensionsDialogAnimation = useDialogCloseAnimation(() => {
+        closeExtensionsDialogOriginal();
+    });
+    // Wrapped handler that triggers animation before closing
+    const closeSettingsDialog = useCallback(() => {
+        settingsDialogAnimation.startClosing();
+    }, [settingsDialogAnimation]);
+    const closeExtensionsDialog = useCallback(() => {
+        extensionsDialogAnimation.startClosing();
+    }, [extensionsDialogAnimation]);
+    // Voice config dialog handlers
+    const openVoiceConfigDialog = useCallback(() => {
+        setIsVoiceConfigDialogOpen(true);
+    }, []);
+    const closeVoiceConfigDialogOriginal = useCallback(() => {
+        setIsVoiceConfigDialogOpen(false);
+    }, []);
+    // Animation hook for voice config dialog
+    const voiceConfigDialogAnimation = useDialogCloseAnimation(() => {
+        closeVoiceConfigDialogOriginal();
+    });
+    const closeVoiceConfigDialog = useCallback(() => {
+        voiceConfigDialogAnimation.startClosing();
+    }, [voiceConfigDialogAnimation]);
     const { isSubagentCreateDialogOpen, openSubagentCreateDialog, closeSubagentCreateDialog, } = useSubagentCreateDialog();
     const { isAgentsManagerDialogOpen, openAgentsManagerDialog, closeAgentsManagerDialog, } = useAgentsManagerDialog();
+    const { isMultiAgentConfigDialogOpen, openMultiAgentConfigDialog, closeMultiAgentConfigDialog, } = useMultiAgentConfigCommand();
     const { isFolderTrustDialogOpen, handleFolderTrustSelect, isRestarting } = useFolderTrust(settings, setIsTrustedFolder);
     const { showQuitConfirmation, handleQuitConfirmationSelect } = useQuitConfirmation();
-    const { isAuthDialogOpen, openAuthDialog, handleAuthSelect, isAuthenticating, cancelAuthentication, } = useAuthCommand(settings, setAuthError, config);
+    const [isHistoryBrowserOpen, setIsHistoryBrowserOpen] = useState(false);
+    const openHistoryBrowser = useCallback(() => {
+        setIsHistoryBrowserOpen(true);
+    }, []);
+    // Create a ref to store reloadCommands that will be set later
+    const reloadCommandsRef = useRef(null);
+    const { isAuthDialogOpen, openAuthDialog, handleAuthSelect: handleAuthSelectOriginal, isAuthenticating, cancelAuthentication, } = useAuthCommand(settings, setAuthError, config, () => {
+        if (reloadCommandsRef.current) {
+            reloadCommandsRef.current();
+        }
+    });
+    // Animation hook for auth dialog
+    const authDialogAnimation = useDialogCloseAnimation(() => {
+        // Close handler - for ESC case
+    });
+    // Wrapped handler that triggers animation before closing
+    const handleAuthSelect = useCallback(async (authMethod, scope, providerName) => {
+        // Start animation first
+        authDialogAnimation.startClosing();
+        // Then do the work (original handler does work and closes)
+        void handleAuthSelectOriginal(authMethod, scope, providerName);
+    }, [handleAuthSelectOriginal, authDialogAnimation]);
     const { isBlackboxAuthenticating, deviceAuth, isBlackboxAuth, cancelBlackboxAuth, authStatus, authMessage, } = useBlackboxAuth(settings, isAuthenticating);
     useEffect(() => {
         if (settings.merged.security?.auth?.selectedType &&
             !settings.merged.security?.auth?.useExternal) {
-            const error = validateAuthMethod(settings.merged.security.auth.selectedType);
+            const selectedProvider = settings.merged.security?.auth?.selectedProvider;
+            const error = validateAuthMethod(settings.merged.security.auth.selectedType, selectedProvider);
             if (error) {
                 setAuthError(error);
                 openAuthDialog();
@@ -220,6 +381,7 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     }, [
         settings.merged.security?.auth?.selectedType,
         settings.merged.security?.auth?.useExternal,
+        settings.merged.security?.auth?.selectedProvider,
         openAuthDialog,
         setAuthError,
     ]);
@@ -233,11 +395,10 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     // Handle Blackbox OAuth timeout
     useEffect(() => {
         if (isBlackboxAuth && authStatus === 'timeout') {
-            setAuthError(authMessage ||
-                'Blackbox OAuth authentication timed out. Please try again or select a different authentication method.');
+            // Don't set error or open dialog - just cancel and return to agent
+            // The user will see they're back at the agent prompt
             cancelBlackboxAuth();
             cancelAuthentication();
-            openAuthDialog();
         }
     }, [
         isBlackboxAuth,
@@ -245,8 +406,6 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
         authMessage,
         cancelBlackboxAuth,
         cancelAuthentication,
-        openAuthDialog,
-        setAuthError,
     ]);
     const { isEditorDialogOpen, openEditorDialog, handleEditorSelect, exitEditorDialog, } = useEditorSettings(settings, setEditorError, addItem);
     const toggleCorgiMode = useCallback(() => {
@@ -417,11 +576,16 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     const handleModelSelectionClose = useCallback(() => {
         setIsModelSelectionDialogOpen(false);
     }, []);
+    // Animation hook for model selection dialog
+    const modelDialogAnimation = useDialogCloseAnimation(() => {
+        setIsModelSelectionDialogOpen(false);
+    });
     const handleModelSelect = useCallback(async (modelId) => {
         try {
             await config.setModel(modelId);
             setCurrentModel(modelId);
-            setIsModelSelectionDialogOpen(false);
+            // Start animation before closing
+            modelDialogAnimation.startClosing();
             addItem({
                 type: MessageType.INFO,
                 text: `Switched model to \`${modelId}\` for this session.`,
@@ -434,8 +598,9 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
                 text: `Failed to switch to model \`${modelId}\`. Please try again.`,
             }, Date.now());
         }
-    }, [config, setCurrentModel, addItem]);
-    const getAvailableModelsForCurrentAuth = useCallback(() => {
+    }, [config, setCurrentModel, addItem, modelDialogAnimation]);
+    const [availableModelsForDialog, setAvailableModelsForDialog] = useState([]);
+    const getAvailableModelsForCurrentAuth = useCallback(async () => {
         const contentGeneratorConfig = config.getContentGeneratorConfig();
         if (!contentGeneratorConfig)
             return [];
@@ -443,17 +608,69 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
         switch (contentGeneratorConfig.authType) {
             case AuthType.BLACKBOX_OAUTH:
                 return getFilteredBlackboxModels(visionModelPreviewEnabled);
-            case AuthType.USE_OPENAI: {
-                const openAIModel = getOpenAIAvailableModelFromEnv();
-                return openAIModel ? [openAIModel] : [];
+            case AuthType.USE_OPENAI:
+            case AuthType.USE_BLACKBOX_API: {
+                const apiKey = contentGeneratorConfig.apiKey;
+                if (!apiKey) {
+                    if (contentGeneratorConfig.authType === AuthType.USE_BLACKBOX_API) {
+                        return [];
+                    }
+                    const openAIModel = getOpenAIAvailableModelFromEnv();
+                    return openAIModel ? [openAIModel] : [];
+                }
+                try {
+                    // Import fetchModelsForProvider dynamically
+                    const { fetchModelsForProvider } = await import('../config/modelFetcher.js');
+                    // IMPORTANT: Get provider name from settings - this determines which provider's models to show
+                    // The /model command should ONLY show models from the currently configured provider
+                    // To switch providers, users must use /configure command
+                    const providerName = settings.merged.security?.auth?.selectedProvider ||
+                        (contentGeneratorConfig.authType === AuthType.USE_BLACKBOX_API ? 'blackbox' : 'openai');
+                    // Get baseUrl from config
+                    const baseUrl = contentGeneratorConfig.baseUrl || 'https://api.openai.com';
+                    // Fetch models using the unified function - this will only return models from the active provider
+                    const modelIds = await fetchModelsForProvider(providerName, apiKey, baseUrl);
+                    if (modelIds.length === 0) {
+                        if (contentGeneratorConfig.authType === AuthType.USE_BLACKBOX_API) {
+                            return [];
+                        }
+                        const openAIModel = getOpenAIAvailableModelFromEnv();
+                        return openAIModel ? [openAIModel] : [];
+                    }
+                    // Convert model IDs to AvailableModel format
+                    return modelIds.map((id) => ({
+                        id,
+                        label: id,
+                    }));
+                }
+                catch (error) {
+                    console.warn('Failed to fetch models:', error);
+                    if (contentGeneratorConfig.authType === AuthType.USE_BLACKBOX_API) {
+                        return [];
+                    }
+                    const openAIModel = getOpenAIAvailableModelFromEnv();
+                    return openAIModel ? [openAIModel] : [];
+                }
             }
             default:
                 return [];
         }
-    }, [config, settings.merged.experimental?.visionModelPreview]);
+    }, [config, settings.merged.experimental?.visionModelPreview, settings.merged.security?.auth?.selectedProvider]);
+    // Fetch models when dialog opens
+    useEffect(() => {
+        if (isModelSelectionDialogOpen) {
+            getAvailableModelsForCurrentAuth().then(setAvailableModelsForDialog);
+        }
+    }, [isModelSelectionDialogOpen, getAvailableModelsForCurrentAuth]);
     // Core hooks and processors
     const { vimEnabled: vimModeEnabled, vimMode, toggleVimEnabled, } = useVimMode();
-    const { handleSlashCommand, slashCommands, pendingHistoryItems: pendingSlashCommandHistoryItems, commandContext, shellConfirmationRequest, confirmationRequest, quitConfirmationRequest, } = useSlashCommandProcessor(config, settings, addItem, clearItems, loadHistory, refreshStatic, setDebugMessage, openThemeDialog, openAuthDialog, openEditorDialog, toggleCorgiMode, setQuittingMessages, openPrivacyNotice, openSettingsDialog, handleModelSelectionOpen, openSubagentCreateDialog, openAgentsManagerDialog, toggleVimEnabled, setIsProcessing, setGeminiMdFileCount, showQuitConfirmation);
+    const { handleSlashCommand, slashCommands, pendingHistoryItems: pendingSlashCommandHistoryItems, commandContext, shellConfirmationRequest, confirmationRequest, quitConfirmationRequest, } = useSlashCommandProcessor(config, settings, addItem, clearItems, loadHistory, refreshStatic, setDebugMessage, openThemeDialog, openAuthDialog, openEditorDialog, toggleCorgiMode, setQuittingMessages, openPrivacyNotice, openSettingsDialog, openExtensionsDialog, handleModelSelectionOpen, openSubagentCreateDialog, openAgentsManagerDialog, openMultiAgentConfigDialog, openHistoryBrowser, openDbConfigureDialog, toggleVimEnabled, setIsProcessing, setGeminiMdFileCount, showQuitConfirmation, openVoiceConfigDialog, openReleasesDialog);
+    // Set the reloadCommands ref when commandContext is available
+    useEffect(() => {
+        if (commandContext?.ui?.reloadCommands) {
+            reloadCommandsRef.current = commandContext.ui.reloadCommands;
+        }
+    }, [commandContext]);
     const buffer = useTextBuffer({
         initialText: '',
         viewport: { height: 10, width: inputWidth },
@@ -465,11 +682,37 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     const [userMessages, setUserMessages] = useState([]);
     // Stable reference for cancel handler to avoid circular dependency
     const cancelHandlerRef = useRef(() => { });
-    const { streamingState, submitQuery, initError, pendingHistoryItems: pendingGeminiHistoryItems, thought, cancelOngoingRequest, } = useGeminiStream(config.getGeminiClient(), history, addItem, config, setDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, refreshStatic, () => cancelHandlerRef.current(), settings.merged.experimental?.visionModelPreview ?? true, handleVisionSwitchRequired);
+    const { streamingState, submitQuery, initError, pendingHistoryItems: pendingGeminiHistoryItems, thought, cancelOngoingRequest, isEncryptedMode: _isEncryptedMode, } = useAdaptiveStream(config, history, addItem, setDebugMessage, () => cancelHandlerRef.current(), {
+        handleSlashCommand,
+        shellModeActive,
+        getPreferredEditor,
+        onAuthError,
+        performMemoryRefresh,
+        modelSwitchedFromQuotaError,
+        setModelSwitchedFromQuotaError,
+        onEditorClose: refreshStatic,
+        visionModelPreviewEnabled: settings.merged.experimental?.visionModelPreview ?? true,
+        onVisionSwitchRequired: handleVisionSwitchRequired,
+    });
     const pendingHistoryItems = useMemo(() => [...pendingSlashCommandHistoryItems, ...pendingGeminiHistoryItems].map((item, index) => ({
         ...item,
         id: index,
     })), [pendingSlashCommandHistoryItems, pendingGeminiHistoryItems]);
+    // Callback for when voice config is completed successfully
+    // Placed here after submitQuery is defined
+    const handleVoiceConfigComplete = useCallback(() => {
+        // Always auto-start recording after config is saved
+        closeVoiceConfigDialog();
+        // Start voice recording immediately after dialog closes
+        // Small delay only for dialog animation to complete smoothly
+        setTimeout(async () => {
+            const result = await handleSlashCommand('/voice record');
+            // If the voice command returns a prompt to submit, submit it to the model
+            if (result && result.type === 'submit_prompt') {
+                submitQuery(result.content);
+            }
+        }, 150); // Minimal delay for smooth animation transition
+    }, [closeVoiceConfigDialog, handleSlashCommand, submitQuery]);
     // Welcome back functionality
     const { welcomeBackInfo, showWelcomeBackDialog, welcomeBackChoice, handleWelcomeBackSelection, handleWelcomeBackClose, } = useWelcomeBack(config, submitQuery, buffer, settings.merged);
     // Dialog close functionality
@@ -483,12 +726,22 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
         exitEditorDialog,
         isSettingsDialogOpen,
         closeSettingsDialog,
+        isExtensionsDialogOpen,
+        closeExtensionsDialog,
+        isVoiceConfigDialogOpen,
+        closeVoiceConfigDialog,
+        isReleasesDialogOpen,
+        closeReleasesDialog,
         isFolderTrustDialogOpen,
         showPrivacyNotice,
         setShowPrivacyNotice,
         showWelcomeBackDialog,
         handleWelcomeBackClose,
         quitConfirmationRequest,
+        showTodoListDialog,
+        setShowTodoListDialog,
+        isDbConfigureDialogOpen,
+        closeDbConfigureDialog: cancelDbConfigure,
     });
     // Message queue for handling input during streaming
     const { messageQueue, addMessage, clearQueue, getQueuedMessagesText } = useMessageQueue({
@@ -523,23 +776,9 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     const handleFinalSubmit = useCallback((submittedValue) => {
         addMessage(submittedValue);
     }, [addMessage]);
-    const handleIdePromptComplete = useCallback((result) => {
-        if (result.userSelection === 'yes') {
-            if (result.isExtensionPreInstalled) {
-                handleSlashCommand('/ide enable');
-            }
-            else {
-                handleSlashCommand('/ide install');
-            }
-            settings.setValue(SettingScope.User, 'hasSeenIdeIntegrationNudge', true);
-        }
-        else if (result.userSelection === 'dismiss') {
-            settings.setValue(SettingScope.User, 'hasSeenIdeIntegrationNudge', true);
-        }
-        setIdePromptAnswered(true);
-    }, [handleSlashCommand, settings]);
     const { handleInput: vimHandleInput } = useVim(buffer, handleFinalSubmit);
-    const { elapsedTime, currentLoadingPhrase } = useLoadingIndicator(streamingState);
+    const { todos, currentTodo, nextTodo } = useTodoList(config.getSessionId());
+    const { elapsedTime, currentLoadingPhrase } = useLoadingIndicator(streamingState, currentTodo?.content || null);
     const showAutoAcceptIndicator = useAutoAcceptIndicator({ config, addItem });
     const handleExit = useCallback((pressedOnce, setPressedOnce, timerRef) => {
         // Fast double-press: Direct quit (preserve user habit)
@@ -594,6 +833,9 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
         if (keyMatchers[Command.SHOW_ERROR_DETAILS](key)) {
             setShowErrorDetails((prev) => !prev);
         }
+        else if (keyMatchers[Command.SHOW_TODO_LIST](key)) {
+            setShowTodoListDialog((prev) => !prev);
+        }
         else if (keyMatchers[Command.TOGGLE_TOOL_DESCRIPTIONS](key)) {
             const newValue = !showToolDescriptions;
             setShowToolDescriptions(newValue);
@@ -773,6 +1015,37 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
         isModelSelectionDialogOpen,
         isVisionSwitchDialogOpen,
     ]);
+    const initialSlashCommandSubmitted = useRef(false);
+    useEffect(() => {
+        if (initialSlashCommand &&
+            !initialSlashCommandSubmitted.current &&
+            !isAuthenticating &&
+            !isAuthDialogOpen &&
+            !isThemeDialogOpen &&
+            !isEditorDialogOpen &&
+            !isModelSelectionDialogOpen &&
+            !isVisionSwitchDialogOpen &&
+            !isSubagentCreateDialogOpen &&
+            !showPrivacyNotice &&
+            !showWelcomeBackDialog &&
+            welcomeBackChoice !== 'restart') {
+            handleSlashCommand(initialSlashCommand);
+            initialSlashCommandSubmitted.current = true;
+        }
+    }, [
+        initialSlashCommand,
+        handleSlashCommand,
+        isAuthenticating,
+        isAuthDialogOpen,
+        isThemeDialogOpen,
+        isEditorDialogOpen,
+        isSubagentCreateDialogOpen,
+        showPrivacyNotice,
+        showWelcomeBackDialog,
+        welcomeBackChoice,
+        isModelSelectionDialogOpen,
+        isVisionSwitchDialogOpen,
+    ]);
     if (quittingMessages) {
         return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: quittingMessages.map((item) => (_jsx(HistoryItemDisplay, { availableTerminalHeight: constrainHeight ? availableTerminalHeight : undefined, terminalWidth: terminalWidth, item: item, isPending: false, config: config }, item.id))) }));
     }
@@ -787,7 +1060,7 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
     return (_jsx(StreamingContext.Provider, { value: streamingState, children: _jsxs(Box, { flexDirection: "column", width: "90%", children: [_jsx(Static, { items: [
                         _jsxs(Box, { flexDirection: "column", children: [!(settings.merged.ui?.hideBanner || config.getScreenReader()) && _jsx(Header, { version: version, nightly: nightly }), !(settings.merged.ui?.hideTips || config.getScreenReader()) && (_jsx(Tips, { config: config }))] }, "header"),
                         ...history.map((h) => (_jsx(HistoryItemDisplay, { terminalWidth: mainAreaWidth, availableTerminalHeight: staticAreaMaxItemHeight, item: h, isPending: false, config: config, commands: slashCommands }, h.id))),
-                    ], children: (item) => item }, staticKey), _jsx(OverflowProvider, { children: _jsxs(Box, { ref: pendingHistoryItemRef, flexDirection: "column", children: [pendingHistoryItems.map((item) => (_jsx(HistoryItemDisplay, { availableTerminalHeight: constrainHeight ? availableTerminalHeight : undefined, terminalWidth: mainAreaWidth, item: item, isPending: true, config: config, isFocused: !isEditorDialogOpen }, item.id))), _jsx(ShowMoreLines, { constrainHeight: constrainHeight })] }) }), _jsxs(Box, { flexDirection: "column", ref: mainControlsRef, children: [updateInfo && _jsx(UpdateNotification, { message: updateInfo.message }), startupWarnings.length > 0 && (_jsx(Box, { borderStyle: "round", borderColor: Colors.AccentYellow, paddingX: 1, marginY: 1, flexDirection: "column", children: startupWarnings.map((warning, index) => (_jsx(Text, { color: Colors.AccentYellow, children: warning }, index))) })), showWelcomeBackDialog && welcomeBackInfo?.hasHistory && (_jsx(WelcomeBackDialog, { welcomeBackInfo: welcomeBackInfo, onSelect: handleWelcomeBackSelection, onClose: handleWelcomeBackClose })), showWorkspaceMigrationDialog ? (_jsx(WorkspaceMigrationDialog, { workspaceExtensions: workspaceExtensions, onOpen: onWorkspaceMigrationDialogOpen, onClose: onWorkspaceMigrationDialogClose })) : shouldShowIdePrompt && currentIDE ? (_jsx(IdeIntegrationNudge, { ide: currentIDE, onComplete: handleIdePromptComplete })) : isFolderTrustDialogOpen ? (_jsx(FolderTrustDialog, { onSelect: handleFolderTrustSelect, isRestarting: isRestarting })) : quitConfirmationRequest ? (_jsx(QuitConfirmationDialog, { onSelect: (choice) => {
+                    ], children: (item) => item }, staticKey), _jsx(OverflowProvider, { children: _jsxs(Box, { ref: pendingHistoryItemRef, flexDirection: "column", children: [pendingHistoryItems.map((item) => (_jsx(HistoryItemDisplay, { availableTerminalHeight: constrainHeight ? availableTerminalHeight : undefined, terminalWidth: mainAreaWidth, item: item, isPending: true, config: config, isFocused: !isEditorDialogOpen }, item.id))), _jsx(ShowMoreLines, { constrainHeight: constrainHeight })] }) }), _jsxs(Box, { flexDirection: "column", ref: mainControlsRef, children: [updateInfo && _jsx(UpdateNotification, { message: updateInfo.message }), startupWarnings.length > 0 && (_jsx(Box, { borderStyle: "round", borderColor: Colors.Gray, paddingX: 1, marginY: 1, flexDirection: "column", children: startupWarnings.map((warning, index) => (_jsx(Text, { color: Colors.Gray, children: warning }, index))) })), showWelcomeBackDialog && welcomeBackInfo?.hasHistory && (_jsx(WelcomeBackDialog, { welcomeBackInfo: welcomeBackInfo, onSelect: handleWelcomeBackSelection, onClose: handleWelcomeBackClose })), showWorkspaceMigrationDialog ? (_jsx(WorkspaceMigrationDialog, { workspaceExtensions: workspaceExtensions, onOpen: onWorkspaceMigrationDialogOpen, onClose: onWorkspaceMigrationDialogClose })) : isFolderTrustDialogOpen ? (_jsx(FolderTrustDialog, { onSelect: handleFolderTrustSelect, isRestarting: isRestarting })) : quitConfirmationRequest ? (_jsx(QuitConfirmationDialog, { onSelect: (choice) => {
                                 const result = handleQuitConfirmationSelect(choice);
                                 if (result?.shouldQuit) {
                                     quitConfirmationRequest.onConfirm(true, result.action);
@@ -795,35 +1068,111 @@ const App = ({ config, settings, startupWarnings = [], version }) => {
                                 else {
                                     quitConfirmationRequest.onConfirm(false);
                                 }
-                            } })) : shellConfirmationRequest ? (_jsx(ShellConfirmationDialog, { request: shellConfirmationRequest })) : confirmationRequest ? (_jsxs(Box, { flexDirection: "column", children: [confirmationRequest.prompt, _jsx(Box, { paddingY: 1, children: _jsx(RadioButtonSelect, { isFocused: !!confirmationRequest, items: [
+                            } })) : shellConfirmationRequest ? (_jsx(ShellConfirmationDialogWithAnimation, { request: shellConfirmationRequest })) : isDbConfigureDialogOpen ? (_jsx(ConfigureUI, { mode: "db", embedded: true, onComplete: completeDbConfigure, onCancel: cancelDbConfigure })) : confirmationRequest ? (_jsxs(Box, { flexDirection: "column", children: [confirmationRequest.prompt, _jsx(Box, { paddingY: 1, children: _jsx(RadioButtonSelect, { isFocused: !!confirmationRequest, items: [
                                             { label: 'Yes', value: true },
                                             { label: 'No', value: false },
                                         ], onSelect: (value) => {
                                             confirmationRequest.onConfirm(value);
                                         } }) })] })) : isThemeDialogOpen ? (_jsxs(Box, { flexDirection: "column", children: [themeError && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: Colors.AccentRed, children: themeError }) })), _jsx(ThemeDialog, { onSelect: handleThemeSelect, onHighlight: handleThemeHighlight, settings: settings, availableTerminalHeight: constrainHeight
                                         ? terminalHeight - staticExtraHeight
-                                        : undefined, terminalWidth: mainAreaWidth })] })) : isSettingsDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(SettingsDialog, { settings: settings, onSelect: () => closeSettingsDialog(), onRestartRequest: () => process.exit(0) }) })) : isSubagentCreateDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(AgentCreationWizard, { onClose: closeSubagentCreateDialog, config: config }) })) : isAgentsManagerDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(AgentsManagerDialog, { onClose: closeAgentsManagerDialog, config: config }) })) : isAuthenticating ? (_jsxs(_Fragment, { children: [isBlackboxAuth && isBlackboxAuthenticating ? (_jsx(BlackboxOAuthProgress, { deviceAuth: deviceAuth || undefined, authStatus: authStatus, authMessage: authMessage, onTimeout: () => {
-                                        setAuthError('Blackbox OAuth authentication timed out. Please try again.');
+                                        : undefined, terminalWidth: mainAreaWidth, isClosing: themeDialogAnimation.isClosing })] })) : isReleasesDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(ReleaseNotesDialog, { versions: releasesVersions, onClose: closeReleasesDialog, availableTerminalHeight: constrainHeight
+                                    ? terminalHeight - staticExtraHeight
+                                    : undefined, terminalWidth: mainAreaWidth, isLoading: isReleasesLoading }) })) : isSettingsDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(SettingsDialog, { settings: settings, onSelect: () => closeSettingsDialog(), onRestartRequest: () => process.exit(0), isClosing: settingsDialogAnimation.isClosing }) })) : isExtensionsDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(ExtensionsDialog, { onClose: () => closeExtensionsDialog() }) })) : isSubagentCreateDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(AgentCreationWizard, { onClose: closeSubagentCreateDialog, config: config }) })) : isAgentsManagerDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(AgentsManagerDialog, { onClose: closeAgentsManagerDialog, config: config }) })) : isMultiAgentConfigDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(MultiAgentConfigDialog, { onComplete: (multiAgentConfig) => {
+                                    // Save configuration to settings
+                                    settings.setValue(SettingScope.User, 'multiAgent', multiAgentConfig);
+                                    closeMultiAgentConfigDialog();
+                                    addItem({
+                                        type: MessageType.INFO,
+                                        text: 'Multi-agent configuration saved successfully.',
+                                    }, Date.now());
+                                }, onCancel: closeMultiAgentConfigDialog, initialConfig: {
+                                    blackbox: {
+                                        enabled: settings.merged.multiAgent?.blackbox?.enabled ?? true,
+                                        model: settings.merged.multiAgent?.blackbox?.model || 'blackboxai/anthropic/claude-sonnet-4.5',
+                                    },
+                                    claude: {
+                                        enabled: settings.merged.multiAgent?.claude?.enabled ?? true,
+                                        model: settings.merged.multiAgent?.claude?.model || 'blackboxai/anthropic/claude-sonnet-4.5',
+                                    },
+                                    codex: {
+                                        enabled: settings.merged.multiAgent?.codex?.enabled ?? true,
+                                        model: settings.merged.multiAgent?.codex?.model || 'gpt-5-codex',
+                                    },
+                                    gemini: {
+                                        enabled: settings.merged.multiAgent?.gemini?.enabled ?? false,
+                                        model: settings.merged.multiAgent?.gemini?.model || 'gemini-2.0-flash-exp',
+                                    },
+                                }, hasOpenAIKey: !!process.env['OPENAI_API_KEY']?.startsWith('sk-'), hasGeminiKey: !!process.env['GEMINI_API_KEY'] }) })) : isHistoryBrowserOpen && logger ? (_jsx(Box, { flexDirection: "column", children: _jsx(HistoryBrowserDialog, { logger: logger, onResume: async (tag) => {
+                                    try {
+                                        const conversation = await logger.loadCheckpoint(tag);
+                                        if (conversation) {
+                                            setIsHistoryBrowserOpen(false);
+                                            // Set the client history so AI has context
+                                            config.getGeminiClient()?.setHistory(conversation);
+                                            // Convert Content[] to HistoryItem[] using the same logic as resumeCommand
+                                            const rolemap = {
+                                                user: MessageType.USER,
+                                                model: MessageType.GEMINI,
+                                            };
+                                            const uiHistory = [];
+                                            let hasSystemPrompt = false;
+                                            let i = 0;
+                                            for (const item of conversation) {
+                                                i += 1;
+                                                const text = item.parts
+                                                    ?.filter((m) => !!m.text)
+                                                    .map((m) => m.text)
+                                                    .join('') || '';
+                                                if (!text) {
+                                                    continue;
+                                                }
+                                                if (i === 1 && text.match(/context for our chat/)) {
+                                                    hasSystemPrompt = true;
+                                                }
+                                                if (i > 2 || !hasSystemPrompt) {
+                                                    uiHistory.push({
+                                                        type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
+                                                        text,
+                                                    });
+                                                }
+                                            }
+                                            // Add IDs to history items
+                                            const historyWithIds = uiHistory.map((item, index) => ({
+                                                ...item,
+                                                id: index,
+                                            }));
+                                            loadHistory(historyWithIds);
+                                        }
+                                    }
+                                    catch (error) {
+                                        console.error('Failed to resume conversation:', error);
+                                    }
+                                }, onDelete: async (tag) => {
+                                    try {
+                                        await logger.deleteCheckpoint(tag);
+                                    }
+                                    catch (error) {
+                                        console.error('Failed to delete checkpoint:', error);
+                                    }
+                                }, onClose: () => setIsHistoryBrowserOpen(false) }) })) : isAuthenticating ? (_jsxs(_Fragment, { children: [isBlackboxAuth && isBlackboxAuthenticating ? (_jsx(BlackboxOAuthProgress, { deviceAuth: deviceAuth || undefined, authStatus: authStatus, authMessage: authMessage, onTimeout: () => {
+                                        // User cancelled - just return to agent without showing dialog
                                         cancelBlackboxAuth();
                                         cancelAuthentication();
-                                        openAuthDialog();
                                     }, onCancel: () => {
-                                        setAuthError('Blackbox OAuth authentication cancelled.');
+                                        // User cancelled - just return to agent without showing dialog
                                         cancelBlackboxAuth();
                                         cancelAuthentication();
-                                        openAuthDialog();
                                     } })) : (_jsx(AuthInProgress, { onTimeout: () => {
-                                        setAuthError('Authentication timed out. Please try again.');
+                                        // User cancelled - just return to agent without showing dialog
                                         cancelAuthentication();
-                                        openAuthDialog();
-                                    } })), showErrorDetails && (_jsx(OverflowProvider, { children: _jsxs(Box, { flexDirection: "column", children: [_jsx(DetailedMessagesDisplay, { messages: filteredConsoleMessages, maxHeight: constrainHeight ? debugConsoleMaxHeight : undefined, width: inputWidth }), _jsx(ShowMoreLines, { constrainHeight: constrainHeight })] }) }))] })) : isAuthDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(AuthDialog, { onSelect: handleAuthSelect, settings: settings, initialErrorMessage: authError, config: config }) })) : isEditorDialogOpen ? (_jsxs(Box, { flexDirection: "column", children: [editorError && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: Colors.AccentRed, children: editorError }) })), _jsx(EditorSettingsDialog, { onSelect: handleEditorSelect, settings: settings, onExit: exitEditorDialog })] })) : isModelSelectionDialogOpen ? (_jsx(ModelSelectionDialog, { availableModels: getAvailableModelsForCurrentAuth(), currentModel: currentModel, onSelect: handleModelSelect, onCancel: handleModelSelectionClose })) : isVisionSwitchDialogOpen ? (_jsx(ModelSwitchDialog, { onSelect: handleVisionSwitchSelect })) : showPrivacyNotice ? (_jsx(PrivacyNotice, { onExit: () => setShowPrivacyNotice(false), config: config })) : (_jsxs(_Fragment, { children: [_jsx(LoadingIndicator, { thought: streamingState === StreamingState.WaitingForConfirmation ||
+                                    } })), showErrorDetails && (_jsx(OverflowProvider, { children: _jsxs(Box, { flexDirection: "column", children: [_jsx(DetailedMessagesDisplay, { messages: filteredConsoleMessages, maxHeight: constrainHeight ? debugConsoleMaxHeight : undefined, width: inputWidth }), _jsx(ShowMoreLines, { constrainHeight: constrainHeight })] }) }))] })) : isAuthDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(AuthDialog, { onSelect: handleAuthSelect, settings: settings, initialErrorMessage: authError, isClosing: authDialogAnimation.isClosing }) })) : isEditorDialogOpen ? (_jsxs(Box, { flexDirection: "column", children: [editorError && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: Colors.AccentRed, children: editorError }) })), _jsx(EditorSettingsDialog, { onSelect: handleEditorSelect, settings: settings, onExit: exitEditorDialog })] })) : isModelSelectionDialogOpen ? (_jsx(ModelSelectionDialog, { availableModels: availableModelsForDialog, currentModel: currentModel, onSelect: handleModelSelect, onCancel: handleModelSelectionClose, isClosing: modelDialogAnimation.isClosing })) : isVisionSwitchDialogOpen ? (_jsx(ModelSwitchDialog, { onSelect: handleVisionSwitchSelect })) : isVoiceConfigDialogOpen ? (_jsx(Box, { flexDirection: "column", children: _jsx(VoiceConfigDialog, { settings: settings, onClose: closeVoiceConfigDialog, isClosing: voiceConfigDialogAnimation.isClosing, onConfigComplete: handleVoiceConfigComplete }) })) : showPrivacyNotice ? (_jsx(PrivacyNotice, { onExit: () => setShowPrivacyNotice(false), config: config })) : (_jsxs(_Fragment, { children: [showTodoListDialog && (_jsx(TodoListDialog, { todos: todos, onClose: () => setShowTodoListDialog(false) })), _jsx(LoadingIndicator, { thought: streamingState === StreamingState.WaitingForConfirmation ||
                                         config.getAccessibility()?.disableLoadingPhrases ||
                                         config.getScreenReader()
                                         ? undefined
                                         : thought, currentLoadingPhrase: config.getAccessibility()?.disableLoadingPhrases ||
                                         config.getScreenReader()
                                         ? undefined
-                                        : currentLoadingPhrase, elapsedTime: elapsedTime }), messageQueue.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [messageQueue
+                                        : currentLoadingPhrase, currentTodo: currentTodo?.content, nextTodo: nextTodo?.content, tokenCount: sessionStats.lastPromptTokenCount, hasTodos: todos.length > 0, elapsedTime: elapsedTime }), messageQueue.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [messageQueue
                                             .slice(0, MAX_DISPLAYED_QUEUED_MESSAGES)
                                             .map((message, index) => {
                                             // Ensure multi-line messages are collapsed for the preview.