@quantum-ai/gemini-cli 0.45.3

package/packages/cli/dist/src/ui/AppContainer.js

@@ -0,0 +1,2104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useMemo, useState, useCallback, useEffect, useRef, useLayoutEffect, useContext, } from 'react';
+import { ResizeObserver, useApp, useStdout, useStdin, AppContext as InkAppContext, } from 'ink';
+import { App } from './App.js';
+import { AppContext } from './contexts/AppContext.js';
+import { UIStateContext } from './contexts/UIStateContext.js';
+import { QuotaContext } from './contexts/QuotaContext.js';
+import { UIActionsContext, } from './contexts/UIActionsContext.js';
+import { ConfigContext } from './contexts/ConfigContext.js';
+import { AuthState, MessageType, StreamingState, } from './types.js';
+import { checkPermissions } from './hooks/atCommandProcessor.js';
+import { ToolActionsProvider } from './contexts/ToolActionsContext.js';
+import { MouseProvider } from './contexts/MouseContext.js';
+import { ScrollProvider } from './contexts/ScrollProvider.js';
+import { IdeClient, ideContextStore, getErrorMessage, getAllGeminiMdFilenames, AuthType, clearCachedCredentialFile, recordExitFail, ShellExecutionService, saveApiKey, debugLogger, isValidEditorType, coreEvents, CoreEvent, flattenMemory, writeToStdout, disableMouseEvents, enterAlternateScreen, enableMouseEvents, disableLineWrapping, shouldEnterAlternateScreen, startupProfiler, SessionStartSource, SessionEndReason, generateSummary, ChangeAuthRequestedError, ProjectIdRequiredError, buildUserSteeringHintPrompt, logBillingEvent, ApiKeyUpdatedEvent, LegacyAgentProtocol, } from '@quantum-ai/gemini-cli-core';
+import { validateAuthMethod } from '../config/auth.js';
+import process from 'node:process';
+import { useHistory } from './hooks/useHistoryManager.js';
+import { useMemoryMonitor } from './hooks/useMemoryMonitor.js';
+import { useThemeCommand } from './hooks/useThemeCommand.js';
+import { useAuthCommand } from './auth/useAuth.js';
+import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
+import { useEditorSettings } from './hooks/useEditorSettings.js';
+import { useSettingsCommand } from './hooks/useSettingsCommand.js';
+import { useModelCommand } from './hooks/useModelCommand.js';
+import { useVoiceModelCommand } from './hooks/useVoiceModelCommand.js';
+import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
+import { useVimMode } from './contexts/VimModeContext.js';
+import { useOverflowActions, useOverflowState, } from './contexts/OverflowContext.js';
+import { useErrorCount } from './hooks/useConsoleMessages.js';
+import { useTerminalSize } from './hooks/useTerminalSize.js';
+import { calculatePromptWidths } from './components/InputPrompt.js';
+import { calculateMainAreaWidth } from './utils/ui-sizing.js';
+import ansiEscapes from 'ansi-escapes';
+import { basename } from 'node:path';
+import { computeTerminalTitle } from '../utils/windowTitle.js';
+import { useTextBuffer } from './components/shared/text-buffer.js';
+import { useLogger } from './hooks/useLogger.js';
+import { useGeminiStream } from './hooks/useGeminiStream.js';
+import { useAgentStream } from './hooks/useAgentStream.js';
+import {} from './hooks/useExecutionLifecycle.js';
+import { useVim } from './hooks/vim.js';
+import { SettingScope } from '../config/settings.js';
+import {} from '../core/initializer.js';
+import { startAutoMemoryIfEnabled } from '../utils/autoMemory.js';
+import { useFocus } from './hooks/useFocus.js';
+import { useKeypress } from './hooks/useKeypress.js';
+import { KeypressPriority } from './contexts/KeypressContext.js';
+import { Command } from './key/keyMatchers.js';
+import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
+import { useShellInactivityStatus } from './hooks/useShellInactivityStatus.js';
+import { useFolderTrust } from './hooks/useFolderTrust.js';
+import { useIdeTrustListener } from './hooks/useIdeTrustListener.js';
+import {} from './IdeIntegrationNudge.js';
+import { appEvents, AppEvent, TransientMessageType } from '../utils/events.js';
+import {} from './utils/updateCheck.js';
+import { setUpdateHandler } from '../utils/handleAutoUpdate.js';
+import { registerCleanup, removeCleanup, runExitCleanup, } from '../utils/cleanup.js';
+import { relaunchApp } from '../utils/processUtils.js';
+import { useMessageQueue } from './hooks/useMessageQueue.js';
+import { useMcpStatus } from './hooks/useMcpStatus.js';
+import { useApprovalModeIndicator } from './hooks/useApprovalModeIndicator.js';
+import { useSessionStats } from './contexts/SessionContext.js';
+import { useGitBranchName } from './hooks/useGitBranchName.js';
+import { useConfirmUpdateRequests, useExtensionUpdates, } from './hooks/useExtensionUpdates.js';
+import { ShellFocusContext } from './contexts/ShellFocusContext.js';
+import {} from '../config/extension-manager.js';
+import { requestConsentInteractive } from '../config/extensions/consent.js';
+import { useSessionBrowser } from './hooks/useSessionBrowser.js';
+import { useSessionResume } from './hooks/useSessionResume.js';
+import { useIncludeDirsTrust } from './hooks/useIncludeDirsTrust.js';
+import { isWorkspaceTrusted } from '../config/trustedFolders.js';
+import { useSettings } from './contexts/SettingsContext.js';
+import { terminalCapabilityManager } from './utils/terminalCapabilityManager.js';
+import { useInputHistoryStore } from './hooks/useInputHistoryStore.js';
+import { useBanner } from './hooks/useBanner.js';
+import { useTerminalSetupPrompt } from './utils/terminalSetup.js';
+import { useHookDisplayState } from './hooks/useHookDisplayState.js';
+import { useBackgroundTaskManager } from './hooks/useBackgroundTaskManager.js';
+import { WARNING_PROMPT_DURATION_MS, QUEUE_ERROR_DISPLAY_DURATION_MS, EXPAND_HINT_DURATION_MS, } from './constants.js';
+import { NewAgentsChoice } from './components/NewAgentsNotification.js';
+import { isSlashCommand } from './utils/commandUtils.js';
+import { parseSlashCommand } from '../utils/commands.js';
+import { useTerminalTheme } from './hooks/useTerminalTheme.js';
+import { useTimedMessage } from './hooks/useTimedMessage.js';
+import { useIsHelpDismissKey } from './utils/shortcutsHelp.js';
+import { useSuspend } from './hooks/useSuspend.js';
+import { useRunEventNotifications } from './hooks/useRunEventNotifications.js';
+import { isNotificationsEnabled, getNotificationMethod, } from '../utils/terminalNotifications.js';
+import { getLastTurnToolCallIds, isToolExecuting, isToolAwaitingConfirmation, getAllToolCalls, } from './utils/historyUtils.js';
+import { useRepeatedKeyPress } from './hooks/useRepeatedKeyPress.js';
+import { useVisibilityToggle, APPROVAL_MODE_REVEAL_DURATION_MS, } from './hooks/useVisibilityToggle.js';
+import { useKeyMatchers } from './hooks/useKeyMatchers.js';
+import { InputContext } from './contexts/InputContext.js';
+/**
+ * The fraction of the terminal width to allocate to the shell.
+ * This provides horizontal padding.
+ */
+const SHELL_WIDTH_FRACTION = 0.89;
+/**
+ * The number of lines to subtract from the available terminal height
+ * for the shell. This provides vertical padding and space for other UI elements.
+ */
+const SHELL_HEIGHT_PADDING = 10;
+export const AppContainer = (props) => {
+    const isHelpDismissKey = useIsHelpDismissKey();
+    const keyMatchers = useKeyMatchers();
+    const { config, initializationResult, resumedSessionData } = props;
+    const settings = useSettings();
+    const { reset } = useOverflowActions();
+    const notificationsEnabled = isNotificationsEnabled(settings);
+    const notificationMethod = getNotificationMethod(settings);
+    const { setOptions, dumpCurrentFrame, startRecording, stopRecording } = useContext(InkAppContext);
+    const recordingFilenameRef = useRef(null);
+    const historyManager = useHistory({
+        chatRecordingService: config.getGeminiClient()?.getChatRecordingService(),
+    });
+    useMemoryMonitor(historyManager);
+    const isAlternateBuffer = config.getUseAlternateBuffer();
+    const [mouseMode, setMouseMode] = useState(() => config.getUseAlternateBuffer());
+    useEffect(() => {
+        setOptions({
+            stickyHeadersInBackbuffer: mouseMode,
+        });
+        if (mouseMode) {
+            enableMouseEvents();
+        }
+        else {
+            disableMouseEvents();
+        }
+    }, [mouseMode, setOptions]);
+    const [corgiMode, setCorgiMode] = useState(false);
+    const [debugMessage, setDebugMessage] = useState('');
+    const [quittingMessages, setQuittingMessages] = useState(null);
+    const [showPrivacyNotice, setShowPrivacyNotice] = useState(false);
+    const [themeError, setThemeError] = useState(initializationResult.themeError);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [embeddedShellFocused, setEmbeddedShellFocused] = useState(false);
+    const [showDebugProfiler, setShowDebugProfiler] = useState(false);
+    const [customDialog, setCustomDialog] = useState(null);
+    const [copyModeEnabled, setCopyModeEnabled] = useState(false);
+    const [pendingRestorePrompt, setPendingRestorePrompt] = useState(false);
+    const toggleBackgroundTasksRef = useRef(() => { });
+    const isBackgroundTaskVisibleRef = useRef(false);
+    const backgroundTasksRef = useRef(new Map());
+    const [adminSettingsChanged, setAdminSettingsChanged] = useState(false);
+    const [expandedTools, setExpandedTools] = useState(new Set());
+    const toggleExpansion = useCallback((callId) => {
+        setExpandedTools((prev) => {
+            const next = new Set(prev);
+            if (next.has(callId)) {
+                next.delete(callId);
+            }
+            else {
+                next.add(callId);
+            }
+            return next;
+        });
+    }, []);
+    const toggleAllExpansion = useCallback((callIds) => {
+        setExpandedTools((prev) => {
+            const next = new Set(prev);
+            const anyCollapsed = callIds.some((id) => !next.has(id));
+            if (anyCollapsed) {
+                callIds.forEach((id) => next.add(id));
+            }
+            else {
+                callIds.forEach((id) => next.delete(id));
+            }
+            return next;
+        });
+    }, []);
+    const isExpanded = useCallback((callId) => expandedTools.has(callId), [expandedTools]);
+    const [shellModeActive, setShellModeActive] = useState(false);
+    const [isVoiceModeEnabled, setVoiceModeEnabled] = useState(false);
+    const [modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError] = useState(false);
+    const [historyRemountKey, setHistoryRemountKey] = useState(0);
+    const [settingsNonce, setSettingsNonce] = useState(0);
+    const activeHooks = useHookDisplayState();
+    const [updateInfo, setUpdateInfo] = useState(null);
+    const [isTrustedFolder, setIsTrustedFolder] = useState(() => isWorkspaceTrusted(settings.merged).isTrusted);
+    const [queueErrorMessage, setQueueErrorMessage] = useTimedMessage(QUEUE_ERROR_DISPLAY_DURATION_MS);
+    const [newAgents, setNewAgents] = useState(null);
+    const [constrainHeight, setConstrainHeight] = useState(true);
+    const [expandHintTrigger, triggerExpandHint] = useTimedMessage(EXPAND_HINT_DURATION_MS);
+    const showIsExpandableHint = Boolean(expandHintTrigger);
+    const overflowState = useOverflowState();
+    const overflowingIdsSize = overflowState?.overflowingIds.size ?? 0;
+    const hasOverflowState = overflowingIdsSize > 0 || !constrainHeight;
+    /**
+     * Manages the visibility and x-second timer for the expansion hint.
+     *
+     * This effect triggers the timer countdown whenever an overflow is detected
+     * or the user manually toggles the expansion state with Ctrl+O.
+     * By depending on overflowingIdsSize, the timer resets when *new* views
+     * overflow, but avoids infinitely resetting during single-view streaming.
+     *
+     * In alternate buffer mode, we don't trigger the hint automatically on overflow
+     * to avoid noise, but the user can still trigger it manually with Ctrl+O.
+     */
+    useEffect(() => {
+        if (hasOverflowState) {
+            triggerExpandHint(true);
+        }
+    }, [hasOverflowState, overflowingIdsSize, triggerExpandHint]);
+    const [defaultBannerText, setDefaultBannerText] = useState('');
+    const [warningBannerText, setWarningBannerText] = useState('');
+    const [bannerVisible, setBannerVisible] = useState(true);
+    const bannerData = useMemo(() => ({
+        defaultText: defaultBannerText,
+        warningText: warningBannerText,
+    }), [defaultBannerText, warningBannerText]);
+    const { bannerText } = useBanner(bannerData);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const extensionManager = config.getExtensionLoader();
+    // We are in the interactive CLI, update how we request consent and settings.
+    extensionManager.setRequestConsent((description) => requestConsentInteractive(description, addConfirmUpdateExtensionRequest));
+    extensionManager.setRequestSetting();
+    const { addConfirmUpdateExtensionRequest, confirmUpdateExtensionRequests } = useConfirmUpdateRequests();
+    const { extensionsUpdateState, extensionsUpdateStateInternal, dispatchExtensionStateUpdate, } = useExtensionUpdates(extensionManager, historyManager.addItem, config.getEnableExtensionReloading());
+    const [isPermissionsDialogOpen, setPermissionsDialogOpen] = useState(false);
+    const [permissionsDialogProps, setPermissionsDialogProps] = useState(null);
+    const openPermissionsDialog = useCallback((props) => {
+        setPermissionsDialogOpen(true);
+        setPermissionsDialogProps(props ?? null);
+    }, []);
+    const closePermissionsDialog = useCallback(() => {
+        setPermissionsDialogOpen(false);
+        setPermissionsDialogProps(null);
+    }, []);
+    const [isAgentConfigDialogOpen, setIsAgentConfigDialogOpen] = useState(false);
+    const [selectedAgentName, setSelectedAgentName] = useState();
+    const [selectedAgentDisplayName, setSelectedAgentDisplayName] = useState();
+    const [selectedAgentDefinition, setSelectedAgentDefinition] = useState();
+    const openAgentConfigDialog = useCallback((name, displayName, definition) => {
+        setSelectedAgentName(name);
+        setSelectedAgentDisplayName(displayName);
+        setSelectedAgentDefinition(definition);
+        setIsAgentConfigDialogOpen(true);
+    }, []);
+    const closeAgentConfigDialog = useCallback(() => {
+        setIsAgentConfigDialogOpen(false);
+        setSelectedAgentName(undefined);
+        setSelectedAgentDisplayName(undefined);
+        setSelectedAgentDefinition(undefined);
+    }, []);
+    const toggleDebugProfiler = useCallback(() => setShowDebugProfiler((prev) => !prev), []);
+    const [currentModel, setCurrentModel] = useState(config.getModel());
+    const [userTier, setUserTier] = useState(undefined);
+    const [quotaStats, setQuotaStats] = useState(() => {
+        const remaining = config.getQuotaRemaining();
+        const limit = config.getQuotaLimit();
+        const resetTime = config.getQuotaResetTime();
+        return remaining !== undefined ||
+            limit !== undefined ||
+            resetTime !== undefined
+            ? { remaining, limit, resetTime }
+            : undefined;
+    });
+    const [paidTier, setPaidTier] = useState(undefined);
+    const [isConfigInitialized, setConfigInitialized] = useState(false);
+    const logger = useLogger(config);
+    const { inputHistory, addInput, initializeFromLogger } = useInputHistoryStore();
+    // Terminal and layout hooks
+    const { columns: terminalWidth, rows: terminalHeight } = useTerminalSize();
+    const { stdin, setRawMode } = useStdin();
+    const { stdout } = useStdout();
+    const app = useApp();
+    // Additional hooks moved from App.tsx
+    const { stats: sessionStats } = useSessionStats();
+    const branchName = useGitBranchName(config.getTargetDir());
+    // Layout measurements
+    // For performance profiling only
+    const rootUiRef = useRef(null);
+    const lastTitleRef = useRef(null);
+    const staticExtraHeight = 3;
+    useEffect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        (async () => {
+            // Note: the program will not work if this fails so let errors be
+            // handled by the global catch.
+            if (!config.isInitialized()) {
+                await config.initialize();
+            }
+            setConfigInitialized(true);
+            startupProfiler.flush(config);
+            startAutoMemoryIfEnabled(config);
+            const sessionStartSource = resumedSessionData
+                ? SessionStartSource.Resume
+                : SessionStartSource.Startup;
+            const result = await config
+                .getHookSystem()
+                ?.fireSessionStartEvent(sessionStartSource);
+            if (result) {
+                const additionalContext = result.getAdditionalContext();
+                const geminiClient = config.getGeminiClient();
+                if (additionalContext && geminiClient) {
+                    await geminiClient.addHistory({
+                        role: 'user',
+                        parts: [
+                            { text: `<hook_context>${additionalContext}</hook_context>` },
+                        ],
+                    });
+                }
+            }
+            // Fire-and-forget: generate summary for previous session in background
+            generateSummary(config).catch((e) => {
+                debugLogger.warn('Background summary generation failed:', e);
+            });
+        })();
+        const cleanupFn = async () => {
+            // Turn off mouse scroll.
+            disableMouseEvents();
+            // Kill all background shells
+            await Promise.all(Array.from(backgroundTasksRef.current.keys()).map((pid) => ShellExecutionService.kill(pid)));
+            const ideClient = await IdeClient.getInstance();
+            await ideClient.disconnect();
+            // Fire SessionEnd hook on cleanup (only if hooks are enabled)
+            await config?.getHookSystem()?.fireSessionEndEvent(SessionEndReason.Exit);
+        };
+        registerCleanup(cleanupFn);
+        return () => {
+            removeCleanup(cleanupFn);
+            cleanupFn().catch((e) => debugLogger.error('Error during cleanup:', e));
+        };
+    }, [config, resumedSessionData]);
+    useEffect(() => setUpdateHandler(historyManager.addItem, setUpdateInfo), [historyManager.addItem]);
+    // Subscribe to fallback mode and model changes from core
+    useEffect(() => {
+        const handleModelChanged = () => {
+            setCurrentModel(config.getModel());
+        };
+        const handleQuotaChanged = (payload) => {
+            setQuotaStats({
+                remaining: payload.remaining,
+                limit: payload.limit,
+                resetTime: payload.resetTime,
+            });
+        };
+        coreEvents.on(CoreEvent.ModelChanged, handleModelChanged);
+        coreEvents.on(CoreEvent.QuotaChanged, handleQuotaChanged);
+        return () => {
+            coreEvents.off(CoreEvent.ModelChanged, handleModelChanged);
+            coreEvents.off(CoreEvent.QuotaChanged, handleQuotaChanged);
+        };
+    }, [config]);
+    useEffect(() => {
+        const handleSettingsChanged = () => {
+            setSettingsNonce((prev) => prev + 1);
+        };
+        const handleAdminSettingsChanged = () => {
+            setAdminSettingsChanged(true);
+        };
+        const handleAgentsDiscovered = (payload) => {
+            setNewAgents(payload.agents);
+        };
+        coreEvents.on(CoreEvent.SettingsChanged, handleSettingsChanged);
+        coreEvents.on(CoreEvent.AdminSettingsChanged, handleAdminSettingsChanged);
+        coreEvents.on(CoreEvent.AgentsDiscovered, handleAgentsDiscovered);
+        return () => {
+            coreEvents.off(CoreEvent.SettingsChanged, handleSettingsChanged);
+            coreEvents.off(CoreEvent.AdminSettingsChanged, handleAdminSettingsChanged);
+            coreEvents.off(CoreEvent.AgentsDiscovered, handleAgentsDiscovered);
+        };
+    }, [settings]);
+    const { errorCount, clearErrorCount } = useErrorCount();
+    const mainAreaWidth = calculateMainAreaWidth(terminalWidth, config);
+    // Derive widths for InputPrompt using shared helper
+    const { inputWidth, suggestionsWidth } = useMemo(() => {
+        const { inputWidth, suggestionsWidth } = calculatePromptWidths(mainAreaWidth);
+        return { inputWidth, suggestionsWidth };
+    }, [mainAreaWidth]);
+    const staticAreaMaxItemHeight = Math.max(terminalHeight * 4, 100);
+    const getPreferredEditor = useCallback(() => {
+        const val = settings.merged.general.preferredEditor;
+        return isValidEditorType(val) ? val : undefined;
+    }, [settings.merged.general.preferredEditor]);
+    const buffer = useTextBuffer({
+        initialText: '',
+        viewport: { height: 10, width: inputWidth },
+        stdin,
+        setRawMode,
+        escapePastedPaths: true,
+        shellModeActive,
+        getPreferredEditor,
+    });
+    const bufferRef = useRef(buffer);
+    useEffect(() => {
+        bufferRef.current = buffer;
+    }, [buffer]);
+    const stableSetText = useCallback((text) => {
+        bufferRef.current.setText(text);
+    }, []);
+    // Initialize input history from logger (past sessions)
+    useEffect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        initializeFromLogger(logger);
+    }, [logger, initializeFromLogger]);
+    // One-time prompt to suggest running /terminal-setup when it would help.
+    useTerminalSetupPrompt({
+        addConfirmUpdateExtensionRequest,
+        addItem: historyManager.addItem,
+    });
+    const refreshStatic = useCallback(() => {
+        if (!isAlternateBuffer && !config.getUseTerminalBuffer()) {
+            stdout.write(ansiEscapes.clearTerminal);
+            setHistoryRemountKey((prev) => prev + 1);
+        }
+    }, [setHistoryRemountKey, isAlternateBuffer, stdout, config]);
+    const shouldUseAlternateScreen = shouldEnterAlternateScreen(isAlternateBuffer, config.getScreenReader());
+    const handleEditorClose = useCallback(() => {
+        if (shouldUseAlternateScreen) {
+            // The editor may have exited alternate buffer mode so we need to
+            // enter it again to be safe.
+            enterAlternateScreen();
+            enableMouseEvents();
+            disableLineWrapping();
+            app.rerender();
+        }
+        terminalCapabilityManager.enableSupportedModes();
+        refreshStatic();
+    }, [refreshStatic, shouldUseAlternateScreen, app]);
+    const [editorError, setEditorError] = useState(null);
+    const { isEditorDialogOpen, openEditorDialog, handleEditorSelect, exitEditorDialog, } = useEditorSettings(settings, setEditorError, historyManager.addItem);
+    useEffect(() => {
+        coreEvents.on(CoreEvent.ExternalEditorClosed, handleEditorClose);
+        coreEvents.on(CoreEvent.RequestEditorSelection, openEditorDialog);
+        return () => {
+            coreEvents.off(CoreEvent.ExternalEditorClosed, handleEditorClose);
+            coreEvents.off(CoreEvent.RequestEditorSelection, openEditorDialog);
+        };
+    }, [handleEditorClose, openEditorDialog]);
+    useEffect(() => {
+        if (!(settings.merged.ui.hideBanner || config.getScreenReader()) &&
+            bannerVisible &&
+            bannerText) {
+            // The header should show a banner but the Header is rendered in static
+            // so we must trigger a static refresh for it to be visible.
+            refreshStatic();
+        }
+    }, [bannerVisible, bannerText, settings, config, refreshStatic]);
+    const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } = useSettingsCommand();
+    const { isThemeDialogOpen, openThemeDialog, closeThemeDialog, handleThemeSelect, handleThemeHighlight, } = useThemeCommand(settings, setThemeError, historyManager.addItem, initializationResult.themeError, refreshStatic);
+    // Poll for terminal background color changes to auto-switch theme
+    useTerminalTheme(handleThemeSelect, config, refreshStatic);
+    const { authState, setAuthState, authError, onAuthError, apiKeyDefaultValue, reloadApiKey, accountSuspensionInfo, setAccountSuspensionInfo, } = useAuthCommand(settings, config, initializationResult.authError, initializationResult.accountSuspensionInfo);
+    const [authContext, setAuthContext] = useState({});
+    useEffect(() => {
+        if (authState === AuthState.Authenticated && authContext.requiresRestart) {
+            setAuthState(AuthState.AwaitingLoginRestart);
+            setAuthContext({});
+        }
+    }, [authState, authContext, setAuthState]);
+    const { proQuotaRequest, handleProQuotaChoice, validationRequest, handleValidationChoice, 
+    // G1 AI Credits
+    overageMenuRequest, handleOverageMenuChoice, emptyWalletRequest, handleEmptyWalletChoice, } = useQuotaAndFallback({
+        config,
+        historyManager,
+        userTier,
+        paidTier,
+        settings,
+        setModelSwitchedFromQuotaError,
+        onShowAuthSelection: () => setAuthState(AuthState.Updating),
+        errorVerbosity: settings.merged.ui.errorVerbosity,
+    });
+    // Derive auth state variables for backward compatibility with UIStateContext
+    const isAuthDialogOpen = authState === AuthState.Updating;
+    // TODO: Consider handling other auth types that should also skip the blocking screen
+    const isAuthenticating = authState === AuthState.Unauthenticated &&
+        settings.merged.security.auth.selectedType !== AuthType.USE_GEMINI;
+    // Session browser and resume functionality
+    const isGeminiClientInitialized = config.getGeminiClient()?.isInitialized();
+    const { loadHistoryForResume, isResuming } = useSessionResume({
+        config,
+        historyManager,
+        refreshStatic,
+        isGeminiClientInitialized,
+        setQuittingMessages,
+        resumedSessionData,
+        isAuthenticating,
+    });
+    const { isSessionBrowserOpen, openSessionBrowser, closeSessionBrowser, handleResumeSession, handleDeleteSession: handleDeleteSessionSync, } = useSessionBrowser(config, loadHistoryForResume);
+    // Wrap handleDeleteSession to return a Promise for UIActions interface
+    const handleDeleteSession = useCallback(async (session) => {
+        await handleDeleteSessionSync(session);
+    }, [handleDeleteSessionSync]);
+    // Create handleAuthSelect wrapper for backward compatibility
+    const handleAuthSelect = useCallback(async (authType, scope) => {
+        if (authType) {
+            const previousAuthType = config.getContentGeneratorConfig()?.authType ?? 'unknown';
+            if (authType === AuthType.LOGIN_WITH_GOOGLE) {
+                setAuthContext({ requiresRestart: true });
+            }
+            else {
+                setAuthContext({});
+            }
+            await clearCachedCredentialFile();
+            settings.setValue(scope, 'security.auth.selectedType', authType);
+            try {
+                config.setRemoteAdminSettings(undefined);
+                await config.refreshAuth(authType);
+                setAuthState(AuthState.Authenticated);
+                logBillingEvent(config, new ApiKeyUpdatedEvent(previousAuthType, authType));
+            }
+            catch (e) {
+                if (e instanceof ChangeAuthRequestedError) {
+                    return;
+                }
+                if (e instanceof ProjectIdRequiredError) {
+                    // OAuth succeeded but account setup requires project ID
+                    // Show the error message directly without "Failed to authenticate" prefix
+                    onAuthError(getErrorMessage(e));
+                    return;
+                }
+                onAuthError(`Failed to authenticate: ${e instanceof Error ? e.message : String(e)}`);
+                return;
+            }
+            if (authType === AuthType.LOGIN_WITH_GOOGLE &&
+                config.isBrowserLaunchSuppressed()) {
+                writeToStdout(`
+----------------------------------------------------------------
+Logging in with Google... Restarting Gemini CLI to continue.
+----------------------------------------------------------------
+          `);
+                await relaunchApp();
+            }
+        }
+        setAuthState(AuthState.Authenticated);
+    }, [settings, config, setAuthState, onAuthError, setAuthContext]);
+    const handleApiKeySubmit = useCallback(async (apiKey) => {
+        try {
+            onAuthError(null);
+            if (!apiKey.trim()) {
+                onAuthError('API key cannot be empty or whitespace only.');
+                return;
+            }
+            await saveApiKey(apiKey);
+            await reloadApiKey();
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            setAuthState(AuthState.Authenticated);
+        }
+        catch (e) {
+            onAuthError(`Failed to save API key: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }, [setAuthState, onAuthError, reloadApiKey, config]);
+    const handleApiKeyCancel = useCallback(() => {
+        // Go back to auth method selection
+        setAuthState(AuthState.Updating);
+    }, [setAuthState]);
+    // Sync user tier from config when authentication changes
+    useEffect(() => {
+        // Only sync when not currently authenticating
+        if (authState === AuthState.Authenticated) {
+            setUserTier(config.getUserTier());
+            setPaidTier(config.getUserPaidTier());
+        }
+    }, [config, authState]);
+    // Check for enforced auth type mismatch
+    useEffect(() => {
+        if (settings.merged.security.auth.enforcedType &&
+            settings.merged.security.auth.selectedType &&
+            settings.merged.security.auth.enforcedType !==
+                settings.merged.security.auth.selectedType) {
+            onAuthError(`Authentication is enforced to be ${settings.merged.security.auth.enforcedType}, but you are currently using ${settings.merged.security.auth.selectedType}.`);
+        }
+        else if (settings.merged.security.auth.selectedType &&
+            !settings.merged.security.auth.useExternal) {
+            // We skip validation for Gemini API key here because it might be stored
+            // in the keychain, which we can't check synchronously.
+            // The useAuth hook handles validation for this case.
+            if (settings.merged.security.auth.selectedType === AuthType.USE_GEMINI) {
+                return;
+            }
+            const authMethod = settings.merged.security.auth.selectedType;
+            void (async () => {
+                try {
+                    const error = await validateAuthMethod(authMethod);
+                    if (error &&
+                        authMethod === settings.merged.security.auth.selectedType) {
+                        onAuthError(error);
+                    }
+                }
+                catch (e) {
+                    if (authMethod === settings.merged.security.auth.selectedType) {
+                        onAuthError(getErrorMessage(e));
+                    }
+                }
+            })();
+        }
+    }, [
+        settings.merged.security.auth.selectedType,
+        settings.merged.security.auth.enforcedType,
+        settings.merged.security.auth.useExternal,
+        onAuthError,
+    ]);
+    const { isModelDialogOpen, openModelDialog, closeModelDialog } = useModelCommand();
+    const { isVoiceModelDialogOpen, openVoiceModelDialog, closeVoiceModelDialog, } = useVoiceModelCommand();
+    const { toggleVimEnabled } = useVimMode();
+    const setIsBackgroundTaskListOpenRef = useRef(() => { });
+    const [shortcutsHelpVisible, setShortcutsHelpVisible] = useState(false);
+    const { cleanUiDetailsVisible, setCleanUiDetailsVisible, toggleCleanUiDetailsVisible, revealCleanUiDetailsTemporarily, } = useVisibilityToggle();
+    const slashCommandActions = useMemo(() => ({
+        openAuthDialog: () => setAuthState(AuthState.Updating),
+        openThemeDialog,
+        openEditorDialog,
+        openPrivacyNotice: () => setShowPrivacyNotice(true),
+        openSettingsDialog,
+        openSessionBrowser,
+        openModelDialog,
+        openVoiceModelDialog,
+        openAgentConfigDialog,
+        openPermissionsDialog,
+        quit: (messages) => {
+            closeThemeDialog();
+            setQuittingMessages(messages);
+            setTimeout(async () => {
+                await runExitCleanup();
+                process.exit(0);
+            }, 100);
+        },
+        setDebugMessage,
+        toggleCorgiMode: () => setCorgiMode((prev) => !prev),
+        toggleVoiceMode: () => setVoiceModeEnabled((prev) => !prev),
+        toggleDebugProfiler,
+        dispatchExtensionStateUpdate,
+        addConfirmUpdateExtensionRequest,
+        toggleBackgroundTasks: () => {
+            toggleBackgroundTasksRef.current();
+            if (!isBackgroundTaskVisibleRef.current) {
+                setEmbeddedShellFocused(true);
+                if (backgroundTasksRef.current.size > 1) {
+                    setIsBackgroundTaskListOpenRef.current(true);
+                }
+                else {
+                    setIsBackgroundTaskListOpenRef.current(false);
+                }
+            }
+        },
+        toggleShortcutsHelp: () => setShortcutsHelpVisible((visible) => !visible),
+        setText: stableSetText,
+    }), [
+        setAuthState,
+        openThemeDialog,
+        closeThemeDialog,
+        openEditorDialog,
+        openSettingsDialog,
+        openSessionBrowser,
+        openModelDialog,
+        openVoiceModelDialog,
+        openAgentConfigDialog,
+        setQuittingMessages,
+        setDebugMessage,
+        setShowPrivacyNotice,
+        setCorgiMode,
+        dispatchExtensionStateUpdate,
+        openPermissionsDialog,
+        addConfirmUpdateExtensionRequest,
+        toggleDebugProfiler,
+        setShortcutsHelpVisible,
+        stableSetText,
+    ]);
+    const { handleSlashCommand, slashCommands, pendingHistoryItems: pendingSlashCommandHistoryItems, commandContext, confirmationRequest: commandConfirmationRequest, } = useSlashCommandProcessor(config, settings, historyManager.addItem, historyManager.clearItems, historyManager.loadHistory, refreshStatic, toggleVimEnabled, setIsProcessing, slashCommandActions, extensionsUpdateStateInternal, isConfigInitialized, setBannerVisible, setCustomDialog);
+    const [authConsentRequest, setAuthConsentRequest] = useState(null);
+    const [permissionConfirmationRequest, setPermissionConfirmationRequest] = useState(null);
+    useEffect(() => {
+        const handleConsentRequest = (payload) => {
+            setAuthConsentRequest({
+                prompt: payload.prompt,
+                onConfirm: (confirmed) => {
+                    setAuthConsentRequest(null);
+                    payload.onConfirm(confirmed);
+                },
+            });
+        };
+        coreEvents.on(CoreEvent.ConsentRequest, handleConsentRequest);
+        return () => {
+            coreEvents.off(CoreEvent.ConsentRequest, handleConsentRequest);
+        };
+    }, []);
+    const performMemoryRefresh = useCallback(async () => {
+        historyManager.addItem({
+            type: MessageType.INFO,
+            text: 'Refreshing hierarchical memory (GEMINI.md or other context files)...',
+        }, Date.now());
+        try {
+            await config.getMemoryContextManager()?.refresh();
+            config.updateSystemInstructionIfInitialized();
+            const flattenedMemory = flattenMemory(config.getUserMemory());
+            const fileCount = config.getGeminiMdFileCount();
+            historyManager.addItem({
+                type: MessageType.INFO,
+                text: `Memory reloaded successfully. ${flattenedMemory.length > 0
+                    ? `Loaded ${flattenedMemory.length} characters from ${fileCount} file(s)`
+                    : 'No memory content found'}`,
+            }, Date.now());
+            if (config.getDebugMode()) {
+                debugLogger.log(`[DEBUG] Refreshed memory content in config: ${flattenedMemory.substring(0, 200)}...`);
+            }
+        }
+        catch (error) {
+            const errorMessage = getErrorMessage(error);
+            historyManager.addItem({
+                type: MessageType.ERROR,
+                text: `Error refreshing memory: ${errorMessage}`,
+            }, Date.now());
+            debugLogger.warn('Error refreshing memory:', error);
+        }
+    }, [config, historyManager]);
+    const cancelHandlerRef = useRef(() => { });
+    const onCancelSubmit = useCallback((shouldRestorePrompt, clearBuffer = false) => {
+        if (shouldRestorePrompt) {
+            setPendingRestorePrompt(true);
+        }
+        else {
+            setPendingRestorePrompt(false);
+            cancelHandlerRef.current(false, clearBuffer);
+        }
+    }, []);
+    useEffect(() => {
+        if (pendingRestorePrompt) {
+            const lastHistoryUserMsg = historyManager.history.findLast((h) => h.type === 'user');
+            const lastUserMsg = inputHistory.at(-1);
+            if (!lastHistoryUserMsg ||
+                (typeof lastHistoryUserMsg.text === 'string' &&
+                    lastHistoryUserMsg.text === lastUserMsg)) {
+                cancelHandlerRef.current(true);
+                setPendingRestorePrompt(false);
+            }
+        }
+    }, [pendingRestorePrompt, inputHistory, historyManager.history]);
+    const pendingHintsRef = useRef([]);
+    const [pendingHintCount, setPendingHintCount] = useState(0);
+    const consumePendingHints = useCallback(() => {
+        if (pendingHintsRef.current.length === 0) {
+            return null;
+        }
+        const hint = pendingHintsRef.current.join('\n');
+        pendingHintsRef.current = [];
+        setPendingHintCount(0);
+        return hint;
+    }, []);
+    useEffect(() => {
+        const hintListener = (text, source) => {
+            if (source !== 'user_steering' && source !== 'background_completion') {
+                return;
+            }
+            pendingHintsRef.current.push(text);
+            setPendingHintCount((prev) => prev + 1);
+        };
+        config.injectionService.onInjection(hintListener);
+        return () => {
+            config.injectionService.offInjection(hintListener);
+        };
+    }, [config]);
+    const streamAgent = useMemo(() => config?.getAgentSessionInteractiveEnabled()
+        ? new LegacyAgentProtocol({ config, getPreferredEditor })
+        : undefined, [config, getPreferredEditor]);
+    const activeStream = streamAgent
+        ? // eslint-disable-next-line react-hooks/rules-of-hooks
+            useAgentStream({
+                agent: streamAgent,
+                addItem: historyManager.addItem,
+                onCancelSubmit,
+                isShellFocused: embeddedShellFocused,
+                logger,
+            })
+        : // eslint-disable-next-line react-hooks/rules-of-hooks
+            useGeminiStream(config.getGeminiClient(), historyManager.history, historyManager.addItem, config, settings, setDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onCancelSubmit, setEmbeddedShellFocused, terminalWidth, terminalHeight, embeddedShellFocused, consumePendingHints);
+    const { streamingState, submitQuery, initError, pendingHistoryItems: pendingGeminiHistoryItems, thought, cancelOngoingRequest, pendingToolCalls, handleApprovalModeChange, activePtyId, loopDetectionConfirmationRequest, lastOutputTime, backgroundTaskCount, isBackgroundTaskVisible, toggleBackgroundTasks, backgroundCurrentExecution, backgroundTasks, dismissBackgroundTask, retryStatus, } = activeStream;
+    const pendingHistoryItems = useMemo(() => [...pendingSlashCommandHistoryItems, ...pendingGeminiHistoryItems], [pendingSlashCommandHistoryItems, pendingGeminiHistoryItems]);
+    toggleBackgroundTasksRef.current = toggleBackgroundTasks;
+    isBackgroundTaskVisibleRef.current = isBackgroundTaskVisible;
+    backgroundTasksRef.current = backgroundTasks;
+    const { activeBackgroundTaskPid, setIsBackgroundTaskListOpen, isBackgroundTaskListOpen, setActiveBackgroundTaskPid, backgroundTaskHeight, } = useBackgroundTaskManager({
+        backgroundTasks,
+        backgroundTaskCount,
+        isBackgroundTaskVisible,
+        activePtyId,
+        embeddedShellFocused,
+        setEmbeddedShellFocused,
+        terminalHeight,
+    });
+    setIsBackgroundTaskListOpenRef.current = setIsBackgroundTaskListOpen;
+    const lastOutputTimeRef = useRef(0);
+    useEffect(() => {
+        lastOutputTimeRef.current = lastOutputTime;
+    }, [lastOutputTime]);
+    const { shouldShowFocusHint, inactivityStatus } = useShellInactivityStatus({
+        activePtyId,
+        lastOutputTime,
+        streamingState,
+        pendingToolCalls,
+        embeddedShellFocused,
+        isInteractiveShellEnabled: config.isInteractiveShellEnabled(),
+    });
+    const shouldShowActionRequiredTitle = inactivityStatus === 'action_required';
+    const shouldShowSilentWorkingTitle = inactivityStatus === 'silent_working';
+    const handleApprovalModeChangeWithUiReveal = useCallback((mode) => {
+        void handleApprovalModeChange(mode);
+        if (!cleanUiDetailsVisible) {
+            revealCleanUiDetailsTemporarily(APPROVAL_MODE_REVEAL_DURATION_MS);
+        }
+    }, [
+        handleApprovalModeChange,
+        cleanUiDetailsVisible,
+        revealCleanUiDetailsTemporarily,
+    ]);
+    const { isMcpReady } = useMcpStatus(config);
+    const isCompressing = useMemo(() => pendingHistoryItems.some((item) => item.type === MessageType.COMPRESSION && item.compression.isPending), [pendingHistoryItems]);
+    const { messageQueue, addMessage, clearQueue, getQueuedMessagesText, popAllMessages, } = useMessageQueue({
+        isConfigInitialized,
+        streamingState,
+        submitQuery,
+        isMcpReady,
+        isCompressing,
+    });
+    cancelHandlerRef.current = useCallback((shouldRestorePrompt = true, clearBuffer = false) => {
+        if (!clearBuffer && isToolAwaitingConfirmation(pendingHistoryItems)) {
+            return; // Don't clear - user may be composing a follow-up message
+        }
+        // If cancelling (shouldRestorePrompt=false):
+        if (!shouldRestorePrompt) {
+            // Clear the buffer if explicitly requested (e.g., Ctrl+C)
+            if (clearBuffer) {
+                buffer.setText('');
+            }
+            // Otherwise (e.g., Escape), user is in control - preserve whatever text they typed
+            return;
+        }
+        // Restore the last message when shouldRestorePrompt=true
+        const lastUserMessage = inputHistory.at(-1);
+        let textToSet = lastUserMessage || '';
+        const queuedText = getQueuedMessagesText();
+        if (queuedText) {
+            textToSet = textToSet ? `${textToSet}\n\n${queuedText}` : queuedText;
+            clearQueue();
+        }
+        if (textToSet) {
+            buffer.setText(textToSet);
+        }
+    }, [
+        buffer,
+        inputHistory,
+        getQueuedMessagesText,
+        clearQueue,
+        pendingHistoryItems,
+    ]);
+    const handleHintSubmit = useCallback((hint) => {
+        const trimmed = hint.trim();
+        if (!trimmed) {
+            return;
+        }
+        config.injectionService.addInjection(trimmed, 'user_steering');
+        // Render hints with a distinct style.
+        historyManager.addItem({
+            type: 'hint',
+            text: trimmed,
+        });
+    }, [config, historyManager]);
+    const handleFinalSubmit = useCallback(async (submittedValue) => {
+        reset();
+        // Explicitly hide the expansion hint and clear its x-second timer when a new turn begins.
+        triggerExpandHint(null);
+        if (!constrainHeight) {
+            setConstrainHeight(true);
+            if (!isAlternateBuffer) {
+                refreshStatic();
+            }
+        }
+        const isSlash = isSlashCommand(submittedValue.trim());
+        const isIdle = streamingState === StreamingState.Idle;
+        const isAgentRunning = streamingState === StreamingState.Responding ||
+            isToolExecuting(pendingHistoryItems);
+        if (isSlash && isAgentRunning) {
+            const { commandToExecute } = parseSlashCommand(submittedValue, slashCommands ?? []);
+            if (commandToExecute?.isSafeConcurrent) {
+                void handleSlashCommand(submittedValue);
+                addInput(submittedValue);
+                return;
+            }
+        }
+        if (config.isModelSteeringEnabled() && isAgentRunning && !isSlash) {
+            handleHintSubmit(submittedValue);
+            addInput(submittedValue);
+            return;
+        }
+        const isMcpOrConfigReady = isConfigInitialized && isMcpReady;
+        if ((isSlash && isConfigInitialized) ||
+            (!isCompressing && isIdle && isMcpOrConfigReady)) {
+            if (!isSlash) {
+                const permissions = await checkPermissions(submittedValue, config);
+                if (permissions.length > 0) {
+                    setPermissionConfirmationRequest({
+                        files: permissions,
+                        onComplete: (result) => {
+                            setPermissionConfirmationRequest(null);
+                            if (result.allowed) {
+                                permissions.forEach((p) => config.getWorkspaceContext().addReadOnlyPath(p));
+                            }
+                            void submitQuery(submittedValue);
+                        },
+                    });
+                    addInput(submittedValue);
+                    return;
+                }
+            }
+            void submitQuery(submittedValue);
+        }
+        else {
+            // Check messageQueue.length === 0 to only notify on the first queued item
+            if (isIdle &&
+                !isCompressing &&
+                !isMcpOrConfigReady &&
+                messageQueue.length === 0) {
+                coreEvents.emitFeedback('info', !isConfigInitialized
+                    ? 'Initializing... Prompts will be queued.'
+                    : 'Waiting for MCP servers to initialize... Slash commands are still available and prompts will be queued.');
+            }
+            addMessage(submittedValue);
+        }
+        addInput(submittedValue); // Track input for up-arrow history
+    }, [
+        addMessage,
+        addInput,
+        submitQuery,
+        handleSlashCommand,
+        slashCommands,
+        isMcpReady,
+        streamingState,
+        isCompressing,
+        messageQueue.length,
+        pendingHistoryItems,
+        config,
+        constrainHeight,
+        setConstrainHeight,
+        isAlternateBuffer,
+        refreshStatic,
+        reset,
+        handleHintSubmit,
+        isConfigInitialized,
+        triggerExpandHint,
+    ]);
+    const handleClearScreen = useCallback(() => {
+        reset();
+        // Explicitly hide the expansion hint and clear its x-second timer when clearing the screen.
+        triggerExpandHint(null);
+        historyManager.clearItems();
+        clearErrorCount();
+        refreshStatic();
+    }, [
+        historyManager,
+        clearErrorCount,
+        refreshStatic,
+        reset,
+        triggerExpandHint,
+    ]);
+    const { handleInput: vimHandleInput } = useVim(buffer, handleFinalSubmit);
+    /**
+     * Determines if the input prompt should be active and accept user input.
+     * Input is disabled during:
+     * - Initialization errors
+     * - Slash command processing
+     * - Tool confirmations (WaitingForConfirmation state)
+     * - Any future streaming states not explicitly allowed
+     */
+    const isInputActive = !initError &&
+        !isProcessing &&
+        !isResuming &&
+        (streamingState === StreamingState.Idle ||
+            streamingState === StreamingState.Responding ||
+            streamingState === StreamingState.WaitingForConfirmation) &&
+        !proQuotaRequest;
+    const observerRef = useRef(null);
+    useEffect(() => () => {
+        observerRef.current?.disconnect();
+    }, []);
+    const [controlsHeight, setControlsHeight] = useState(0);
+    const [lastNonCopyControlsHeight, setLastNonCopyControlsHeight] = useState(0);
+    useLayoutEffect(() => {
+        if (!copyModeEnabled && controlsHeight > 0) {
+            setLastNonCopyControlsHeight(controlsHeight);
+        }
+    }, [copyModeEnabled, controlsHeight]);
+    const stableControlsHeight = copyModeEnabled && lastNonCopyControlsHeight > 0
+        ? lastNonCopyControlsHeight
+        : controlsHeight;
+    const mainControlsRef = useCallback((node) => {
+        if (observerRef.current) {
+            observerRef.current.disconnect();
+            observerRef.current = null;
+        }
+        if (node) {
+            const observer = new ResizeObserver((entries) => {
+                const entry = entries[0];
+                if (entry) {
+                    const roundedHeight = Math.round(entry.contentRect.height);
+                    setControlsHeight((prev) => roundedHeight !== prev ? roundedHeight : prev);
+                }
+            });
+            observer.observe(node);
+            observerRef.current = observer;
+        }
+    }, []);
+    // Compute available terminal height based on stable controls measurement
+    const availableTerminalHeight = Math.max(0, terminalHeight - stableControlsHeight - backgroundTaskHeight - 1);
+    config.setShellExecutionConfig({
+        terminalWidth: Math.floor(terminalWidth * SHELL_WIDTH_FRACTION),
+        terminalHeight: Math.max(Math.floor(availableTerminalHeight - SHELL_HEIGHT_PADDING), 1),
+        pager: settings.merged.tools.shell.pager,
+        showColor: settings.merged.tools.shell.showColor,
+        sanitizationConfig: config.sanitizationConfig,
+        sandboxManager: config.sandboxManager,
+    });
+    const { isFocused, hasReceivedFocusEvent } = useFocus();
+    // Context file names computation
+    const contextFileNames = useMemo(() => {
+        const fromSettings = settings.merged.context.fileName;
+        return fromSettings
+            ? Array.isArray(fromSettings)
+                ? fromSettings
+                : [fromSettings]
+            : getAllGeminiMdFilenames();
+    }, [settings.merged.context.fileName]);
+    // Initial prompt handling
+    const initialPrompt = useMemo(() => config.getQuestion(), [config]);
+    const initialPromptSubmitted = useRef(false);
+    const geminiClient = config.getGeminiClient();
+    useEffect(() => {
+        if (initialPrompt &&
+            isConfigInitialized &&
+            !initialPromptSubmitted.current &&
+            !isAuthenticating &&
+            !isAuthDialogOpen &&
+            !isThemeDialogOpen &&
+            !isEditorDialogOpen &&
+            !showPrivacyNotice &&
+            geminiClient?.isInitialized?.()) {
+            void handleFinalSubmit(initialPrompt);
+            initialPromptSubmitted.current = true;
+        }
+    }, [
+        initialPrompt,
+        isConfigInitialized,
+        handleFinalSubmit,
+        isAuthenticating,
+        isAuthDialogOpen,
+        isThemeDialogOpen,
+        isEditorDialogOpen,
+        showPrivacyNotice,
+        geminiClient,
+    ]);
+    const [idePromptAnswered, setIdePromptAnswered] = useState(false);
+    const [currentIDE, setCurrentIDE] = useState(null);
+    useEffect(() => {
+        const getIde = async () => {
+            const ideClient = await IdeClient.getInstance();
+            const currentIde = ideClient.getCurrentIde();
+            setCurrentIDE(currentIde || null);
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        getIde();
+    }, []);
+    const shouldShowIdePrompt = Boolean(currentIDE &&
+        !config.getIdeMode() &&
+        !settings.merged.ide.hasSeenNudge &&
+        !idePromptAnswered);
+    const [showErrorDetails, setShowErrorDetails] = useState(false);
+    const [showFullTodos, setShowFullTodos] = useState(false);
+    const [renderMarkdown, setRenderMarkdown] = useState(true);
+    const handleExitRepeat = useCallback((count) => {
+        if (count > 2) {
+            recordExitFail(config);
+        }
+        if (count > 1) {
+            void handleSlashCommand('/quit', undefined, undefined, false);
+        }
+    }, [config, handleSlashCommand]);
+    const { pressCount: ctrlCPressCount, handlePress: handleCtrlCPress } = useRepeatedKeyPress({
+        windowMs: WARNING_PROMPT_DURATION_MS,
+        onRepeat: handleExitRepeat,
+    });
+    const { pressCount: ctrlDPressCount, handlePress: handleCtrlDPress } = useRepeatedKeyPress({
+        windowMs: WARNING_PROMPT_DURATION_MS,
+        onRepeat: handleExitRepeat,
+    });
+    const [ideContextState, setIdeContextState] = useState();
+    const [showEscapePrompt, setShowEscapePrompt] = useState(false);
+    const [showIdeRestartPrompt, setShowIdeRestartPrompt] = useState(false);
+    const [transientMessage, showTransientMessage] = useTimedMessage(WARNING_PROMPT_DURATION_MS);
+    const { isFolderTrustDialogOpen, discoveryResults: folderDiscoveryResults, handleFolderTrustSelect, isRestarting, } = useFolderTrust(settings, setIsTrustedFolder, historyManager.addItem);
+    const policyUpdateConfirmationRequest = config.getPolicyUpdateConfirmationRequest();
+    const [isPolicyUpdateDialogOpen, setIsPolicyUpdateDialogOpen] = useState(!!policyUpdateConfirmationRequest);
+    const { needsRestart: ideNeedsRestart, restartReason: ideTrustRestartReason, } = useIdeTrustListener();
+    useIncludeDirsTrust(config, isTrustedFolder, historyManager, setCustomDialog);
+    const tabFocusTimeoutRef = useRef(null);
+    useEffect(() => {
+        const handleTransientMessage = (payload) => {
+            showTransientMessage({ text: payload.message, type: payload.type });
+        };
+        const handleSelectionWarning = () => {
+            showTransientMessage({
+                text: 'Press Ctrl-S to enter selection mode to copy text.',
+                type: TransientMessageType.Warning,
+            });
+        };
+        const handlePasteTimeout = () => {
+            showTransientMessage({
+                text: 'Paste Timed out. Possibly due to slow connection.',
+                type: TransientMessageType.Warning,
+            });
+        };
+        appEvents.on(AppEvent.TransientMessage, handleTransientMessage);
+        appEvents.on(AppEvent.SelectionWarning, handleSelectionWarning);
+        appEvents.on(AppEvent.PasteTimeout, handlePasteTimeout);
+        return () => {
+            appEvents.off(AppEvent.TransientMessage, handleTransientMessage);
+            appEvents.off(AppEvent.SelectionWarning, handleSelectionWarning);
+            appEvents.off(AppEvent.PasteTimeout, handlePasteTimeout);
+            if (tabFocusTimeoutRef.current) {
+                clearTimeout(tabFocusTimeoutRef.current);
+            }
+        };
+    }, [showTransientMessage]);
+    const handleWarning = useCallback((message) => {
+        showTransientMessage({
+            text: message,
+            type: TransientMessageType.Warning,
+        });
+    }, [showTransientMessage]);
+    const { handleSuspend } = useSuspend({
+        handleWarning,
+        setRawMode,
+        shouldUseAlternateScreen,
+    });
+    useEffect(() => {
+        if (ideNeedsRestart) {
+            // IDE trust changed, force a restart.
+            setShowIdeRestartPrompt(true);
+        }
+    }, [ideNeedsRestart]);
+    useEffect(() => {
+        const unsubscribe = ideContextStore.subscribe(setIdeContextState);
+        setIdeContextState(ideContextStore.get());
+        return unsubscribe;
+    }, []);
+    useEffect(() => {
+        const openDebugConsole = () => {
+            setShowErrorDetails(true);
+            setConstrainHeight(false);
+        };
+        appEvents.on(AppEvent.OpenDebugConsole, openDebugConsole);
+        return () => {
+            appEvents.off(AppEvent.OpenDebugConsole, openDebugConsole);
+        };
+    }, [config]);
+    const handleEscapePromptChange = useCallback((showPrompt) => {
+        setShowEscapePrompt(showPrompt);
+    }, []);
+    const handleIdePromptComplete = useCallback((result) => {
+        if (result.userSelection === 'yes') {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleSlashCommand('/ide install');
+            settings.setValue(SettingScope.User, 'ide.hasSeenNudge', true);
+        }
+        else if (result.userSelection === 'dismiss') {
+            settings.setValue(SettingScope.User, 'ide.hasSeenNudge', true);
+        }
+        setIdePromptAnswered(true);
+    }, [handleSlashCommand, settings]);
+    const handleGlobalKeypress = useCallback((key) => {
+        // Debug log keystrokes if enabled
+        if (settings.merged.general.debugKeystrokeLogging) {
+            debugLogger.log('[DEBUG] Keystroke:', JSON.stringify(key));
+        }
+        if (shortcutsHelpVisible && isHelpDismissKey(key)) {
+            setShortcutsHelpVisible(false);
+        }
+        if (keyMatchers[Command.TOGGLE_MOUSE_MODE](key)) {
+            setMouseMode((prev) => !prev);
+            if (mouseMode && !isAlternateBuffer) {
+                appEvents.emit(AppEvent.ScrollToBottom);
+            }
+            return true;
+        }
+        if (isAlternateBuffer && keyMatchers[Command.TOGGLE_COPY_MODE](key)) {
+            setCopyModeEnabled(true);
+            disableMouseEvents();
+            return true;
+        }
+        if (keyMatchers[Command.QUIT](key)) {
+            // If the user presses Ctrl+C, we want to cancel any ongoing requests.
+            // This should happen regardless of the count.
+            void cancelOngoingRequest?.();
+            handleCtrlCPress();
+            return true;
+        }
+        else if (keyMatchers[Command.EXIT](key)) {
+            // If the input field is non-empty, do not exit.
+            if (bufferRef.current.text.length > 0) {
+                return false;
+            }
+            handleCtrlDPress();
+            return true;
+        }
+        else if (keyMatchers[Command.SUSPEND_APP](key)) {
+            handleSuspend();
+        }
+        else if (keyMatchers[Command.DUMP_FRAME](key)) {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const filename = `snapshot-${timestamp}.json`;
+            if (dumpCurrentFrame) {
+                dumpCurrentFrame(filename);
+                debugLogger.log(`Dumped frame to: ${filename}`);
+            }
+            return true;
+        }
+        else if (keyMatchers[Command.START_RECORDING](key)) {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const filename = `recording-${timestamp}.json`;
+            if (startRecording) {
+                startRecording(filename);
+                recordingFilenameRef.current = filename;
+                debugLogger.log(`Started recording to: ${filename}`);
+            }
+            return true;
+        }
+        else if (keyMatchers[Command.STOP_RECORDING](key)) {
+            if (stopRecording) {
+                stopRecording();
+                debugLogger.log(`Stopped recording, saved to: ${recordingFilenameRef.current ?? 'unknown'}`);
+                recordingFilenameRef.current = null;
+            }
+            return true;
+        }
+        else if (keyMatchers[Command.TOGGLE_COPY_MODE](key) &&
+            !isAlternateBuffer) {
+            showTransientMessage({
+                text: 'Use Ctrl+O to expand and collapse blocks of content.',
+                type: TransientMessageType.Warning,
+            });
+            return true;
+        }
+        const toggleLastTurnTools = () => {
+            triggerExpandHint(true);
+            const targetToolCallIds = getLastTurnToolCallIds(historyManager.history, pendingHistoryItems);
+            if (targetToolCallIds.length > 0) {
+                toggleAllExpansion(targetToolCallIds);
+            }
+        };
+        let enteringConstrainHeightMode = false;
+        if (!constrainHeight) {
+            enteringConstrainHeightMode = true;
+            setConstrainHeight(true);
+            if (keyMatchers[Command.SHOW_MORE_LINES](key)) {
+                toggleLastTurnTools();
+            }
+            if (!isAlternateBuffer) {
+                refreshStatic();
+            }
+        }
+        if (keyMatchers[Command.SHOW_ERROR_DETAILS](key)) {
+            if (settings.merged.general.devtools) {
+                void (async () => {
+                    const { toggleDevToolsPanel } = await import('../utils/devtoolsService.js');
+                    await toggleDevToolsPanel(config, showErrorDetails, () => setShowErrorDetails((prev) => !prev), () => setShowErrorDetails(true));
+                })();
+            }
+            else {
+                setShowErrorDetails((prev) => !prev);
+            }
+            return true;
+        }
+        else if (keyMatchers[Command.SHOW_FULL_TODOS](key)) {
+            setShowFullTodos((prev) => !prev);
+            return true;
+        }
+        else if (keyMatchers[Command.TOGGLE_MARKDOWN](key)) {
+            setRenderMarkdown((prev) => {
+                const newValue = !prev;
+                // Force re-render of static content
+                refreshStatic();
+                return newValue;
+            });
+            return true;
+        }
+        else if (keyMatchers[Command.SHOW_IDE_CONTEXT_DETAIL](key) &&
+            config.getIdeMode() &&
+            ideContextState) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleSlashCommand('/ide status');
+            return true;
+        }
+        else if (keyMatchers[Command.SHOW_MORE_LINES](key) &&
+            !enteringConstrainHeightMode) {
+            setConstrainHeight(false);
+            toggleLastTurnTools();
+            refreshStatic();
+            return true;
+        }
+        else if ((keyMatchers[Command.FOCUS_SHELL_INPUT](key) ||
+            keyMatchers[Command.UNFOCUS_BACKGROUND_SHELL_LIST](key)) &&
+            (activePtyId || (isBackgroundTaskVisible && backgroundTasks.size > 0))) {
+            if (embeddedShellFocused) {
+                const capturedTime = lastOutputTimeRef.current;
+                if (tabFocusTimeoutRef.current)
+                    clearTimeout(tabFocusTimeoutRef.current);
+                tabFocusTimeoutRef.current = setTimeout(() => {
+                    if (lastOutputTimeRef.current === capturedTime) {
+                        setEmbeddedShellFocused(false);
+                    }
+                    else {
+                        showTransientMessage({
+                            text: 'Use Shift+Tab to unfocus',
+                            type: TransientMessageType.Warning,
+                        });
+                    }
+                }, 150);
+                return false;
+            }
+            const isIdle = Date.now() - lastOutputTimeRef.current >= 100;
+            if (isIdle && !activePtyId && !isBackgroundTaskVisible) {
+                if (tabFocusTimeoutRef.current)
+                    clearTimeout(tabFocusTimeoutRef.current);
+                toggleBackgroundTasks();
+                setEmbeddedShellFocused(true);
+                if (backgroundTasks.size > 1)
+                    setIsBackgroundTaskListOpen(true);
+                return true;
+            }
+            setEmbeddedShellFocused(true);
+            return true;
+        }
+        else if (keyMatchers[Command.UNFOCUS_SHELL_INPUT](key) ||
+            keyMatchers[Command.UNFOCUS_BACKGROUND_SHELL](key)) {
+            if (embeddedShellFocused) {
+                setEmbeddedShellFocused(false);
+                return true;
+            }
+            return false;
+        }
+        else if (keyMatchers[Command.TOGGLE_BACKGROUND_SHELL](key)) {
+            if (activePtyId) {
+                backgroundCurrentExecution();
+                // After backgrounding, we explicitly do NOT show or focus the background UI.
+            }
+            else {
+                toggleBackgroundTasks();
+                // Toggle focus based on intent: if we were hiding, unfocus; if showing, focus.
+                if (!isBackgroundTaskVisible && backgroundTasks.size > 0) {
+                    setEmbeddedShellFocused(true);
+                    if (backgroundTasks.size > 1) {
+                        setIsBackgroundTaskListOpen(true);
+                    }
+                }
+                else {
+                    setEmbeddedShellFocused(false);
+                }
+            }
+            return true;
+        }
+        else if (keyMatchers[Command.TOGGLE_BACKGROUND_SHELL_LIST](key)) {
+            if (backgroundTasks.size > 0 && isBackgroundTaskVisible) {
+                if (!embeddedShellFocused) {
+                    setEmbeddedShellFocused(true);
+                }
+                setIsBackgroundTaskListOpen(true);
+            }
+            return true;
+        }
+        return false;
+    }, [
+        constrainHeight,
+        setConstrainHeight,
+        setShowErrorDetails,
+        config,
+        ideContextState,
+        handleCtrlCPress,
+        handleCtrlDPress,
+        handleSlashCommand,
+        cancelOngoingRequest,
+        activePtyId,
+        handleSuspend,
+        embeddedShellFocused,
+        settings.merged.general.debugKeystrokeLogging,
+        refreshStatic,
+        setCopyModeEnabled,
+        tabFocusTimeoutRef,
+        isAlternateBuffer,
+        shortcutsHelpVisible,
+        backgroundCurrentExecution,
+        toggleBackgroundTasks,
+        backgroundTasks,
+        isBackgroundTaskVisible,
+        setIsBackgroundTaskListOpen,
+        lastOutputTimeRef,
+        showTransientMessage,
+        settings.merged.general.devtools,
+        showErrorDetails,
+        triggerExpandHint,
+        keyMatchers,
+        isHelpDismissKey,
+        historyManager.history,
+        pendingHistoryItems,
+        toggleAllExpansion,
+        dumpCurrentFrame,
+        startRecording,
+        stopRecording,
+        mouseMode,
+    ]);
+    useKeypress(handleGlobalKeypress, { isActive: true, priority: true });
+    useKeypress((key) => {
+        if (keyMatchers[Command.SCROLL_UP](key) ||
+            keyMatchers[Command.SCROLL_DOWN](key) ||
+            keyMatchers[Command.PAGE_UP](key) ||
+            keyMatchers[Command.PAGE_DOWN](key) ||
+            keyMatchers[Command.SCROLL_HOME](key) ||
+            keyMatchers[Command.SCROLL_END](key)) {
+            return false;
+        }
+        setCopyModeEnabled(false);
+        if (mouseMode) {
+            enableMouseEvents();
+        }
+        return true;
+    }, {
+        isActive: copyModeEnabled,
+        // We need to receive keypresses first so they do not bubble to other
+        // handlers.
+        priority: KeypressPriority.Critical,
+    });
+    useEffect(() => {
+        // Respect hideWindowTitle settings
+        if (settings.merged.ui.hideWindowTitle)
+            return;
+        const paddedTitle = computeTerminalTitle({
+            streamingState,
+            thoughtSubject: thought?.subject,
+            isConfirming: !!commandConfirmationRequest || shouldShowActionRequiredTitle,
+            isSilentWorking: shouldShowSilentWorkingTitle,
+            folderName: basename(config.getTargetDir()),
+            showThoughts: !!settings.merged.ui.showStatusInTitle,
+            useDynamicTitle: settings.merged.ui.dynamicWindowTitle,
+        });
+        // Only update the title if it's different from the last value we set
+        if (lastTitleRef.current !== paddedTitle) {
+            lastTitleRef.current = paddedTitle;
+            stdout.write(`\x1b]0;${paddedTitle}\x07`);
+        }
+        // Note: We don't need to reset the window title on exit because Gemini CLI is already doing that elsewhere
+    }, [
+        streamingState,
+        thought,
+        commandConfirmationRequest,
+        shouldShowActionRequiredTitle,
+        shouldShowSilentWorkingTitle,
+        settings.merged.ui.showStatusInTitle,
+        settings.merged.ui.dynamicWindowTitle,
+        settings.merged.ui.hideWindowTitle,
+        config,
+        stdout,
+    ]);
+    useEffect(() => {
+        const handleUserFeedback = (payload) => {
+            let type;
+            switch (payload.severity) {
+                case 'error':
+                    type = MessageType.ERROR;
+                    break;
+                case 'warning':
+                    type = MessageType.WARNING;
+                    break;
+                case 'info':
+                    type = MessageType.INFO;
+                    break;
+                default:
+                    throw new Error(`Unexpected severity for user feedback: ${payload.severity}`);
+            }
+            historyManager.addItem({
+                type,
+                text: payload.message,
+            }, Date.now());
+            // If there is an attached error object, log it to the debug drawer.
+            if (payload.error) {
+                debugLogger.warn(`[Feedback Details for "${payload.message}"]`, payload.error);
+            }
+        };
+        const handleHookSystemMessage = (payload) => {
+            historyManager.addItem({
+                type: MessageType.INFO,
+                text: payload.message,
+                source: payload.hookName,
+            }, Date.now());
+        };
+        coreEvents.on(CoreEvent.UserFeedback, handleUserFeedback);
+        coreEvents.on(CoreEvent.HookSystemMessage, handleHookSystemMessage);
+        // Flush any messages that happened during startup before this component
+        // mounted.
+        coreEvents.drainBacklogs();
+        return () => {
+            coreEvents.off(CoreEvent.UserFeedback, handleUserFeedback);
+            coreEvents.off(CoreEvent.HookSystemMessage, handleHookSystemMessage);
+        };
+    }, [historyManager]);
+    const nightly = props.version.includes('nightly');
+    const isAwaitingLoginRestart = authState === AuthState.AwaitingLoginRestart;
+    const loginRestartMessage = settings.merged.security.auth.selectedType === AuthType.USE_VERTEX_AI
+        ? 'Authenticating to Vertex AI in Cloud Shell requires a restart to apply project settings.'
+        : undefined;
+    const dialogsVisible = shouldShowIdePrompt ||
+        isFolderTrustDialogOpen ||
+        isPolicyUpdateDialogOpen ||
+        adminSettingsChanged ||
+        !!commandConfirmationRequest ||
+        !!authConsentRequest ||
+        !!permissionConfirmationRequest ||
+        !!customDialog ||
+        confirmUpdateExtensionRequests.length > 0 ||
+        !!loopDetectionConfirmationRequest ||
+        isThemeDialogOpen ||
+        isSettingsDialogOpen ||
+        isModelDialogOpen ||
+        isVoiceModelDialogOpen ||
+        isAgentConfigDialogOpen ||
+        isPermissionsDialogOpen ||
+        isAuthenticating ||
+        isAuthDialogOpen ||
+        isEditorDialogOpen ||
+        showPrivacyNotice ||
+        showIdeRestartPrompt ||
+        !!proQuotaRequest ||
+        !!validationRequest ||
+        !!overageMenuRequest ||
+        !!emptyWalletRequest ||
+        isSessionBrowserOpen ||
+        authState === AuthState.AwaitingApiKeyInput ||
+        isAwaitingLoginRestart ||
+        !!newAgents;
+    const hasPendingToolConfirmation = useMemo(() => isToolAwaitingConfirmation(pendingHistoryItems), [pendingHistoryItems]);
+    const hasConfirmUpdateExtensionRequests = confirmUpdateExtensionRequests.length > 0;
+    const hasLoopDetectionConfirmationRequest = !!loopDetectionConfirmationRequest;
+    const hasPendingActionRequired = hasPendingToolConfirmation ||
+        !!commandConfirmationRequest ||
+        !!authConsentRequest ||
+        hasConfirmUpdateExtensionRequests ||
+        hasLoopDetectionConfirmationRequest ||
+        !!proQuotaRequest ||
+        !!validationRequest ||
+        !!overageMenuRequest ||
+        !!emptyWalletRequest ||
+        !!customDialog;
+    const loadingPhrases = settings.merged.ui.loadingPhrases;
+    const showStatusTips = loadingPhrases === 'tips' || loadingPhrases === 'all';
+    const showStatusWit = loadingPhrases === 'witty' || loadingPhrases === 'all';
+    const showLoadingIndicator = (!embeddedShellFocused || isBackgroundTaskVisible) &&
+        streamingState === StreamingState.Responding &&
+        !hasPendingActionRequired;
+    let estimatedStatusLength = 0;
+    if (activeHooks.length > 0 && settings.merged.hooksConfig.notifications) {
+        const hookLabel = activeHooks.length > 1 ? 'Executing Hooks' : 'Executing Hook';
+        const hookNames = activeHooks
+            .map((h) => h.name +
+            (h.index && h.total && h.total > 1 ? ` (${h.index}/${h.total})` : ''))
+            .join(', ');
+        estimatedStatusLength = hookLabel.length + hookNames.length + 10;
+    }
+    else if (showLoadingIndicator) {
+        const thoughtText = thought?.subject || 'Waiting for model...';
+        estimatedStatusLength = thoughtText.length + 25;
+    }
+    else if (hasPendingActionRequired) {
+        estimatedStatusLength = 35;
+    }
+    const maxLength = terminalWidth - estimatedStatusLength - 5;
+    const { elapsedTime, currentLoadingPhrase, currentTip, currentWittyPhrase } = useLoadingIndicator({
+        streamingState,
+        shouldShowFocusHint,
+        retryStatus,
+        showTips: showStatusTips,
+        showWit: showStatusWit,
+        customWittyPhrases: settings.merged.ui.customWittyPhrases,
+        errorVerbosity: settings.merged.ui.errorVerbosity,
+        maxLength,
+    });
+    const allowPlanMode = config.isPlanEnabled() &&
+        streamingState === StreamingState.Idle &&
+        !hasPendingActionRequired;
+    const showApprovalModeIndicator = useApprovalModeIndicator({
+        config,
+        addItem: historyManager.addItem,
+        onApprovalModeChange: handleApprovalModeChangeWithUiReveal,
+        isActive: !embeddedShellFocused,
+        allowPlanMode,
+    });
+    useRunEventNotifications({
+        notificationsEnabled,
+        notificationMethod,
+        isFocused,
+        hasReceivedFocusEvent,
+        streamingState,
+        hasPendingActionRequired,
+        pendingHistoryItems,
+        commandConfirmationRequest,
+        authConsentRequest,
+        permissionConfirmationRequest,
+        hasConfirmUpdateExtensionRequests,
+        hasLoopDetectionConfirmationRequest,
+    });
+    const isPassiveShortcutsHelpState = isInputActive &&
+        streamingState === StreamingState.Idle &&
+        !hasPendingActionRequired;
+    useEffect(() => {
+        if (shortcutsHelpVisible && !isPassiveShortcutsHelpState) {
+            setShortcutsHelpVisible(false);
+        }
+    }, [
+        shortcutsHelpVisible,
+        isPassiveShortcutsHelpState,
+        setShortcutsHelpVisible,
+    ]);
+    useEffect(() => {
+        if (!isConfigInitialized ||
+            !config.isModelSteeringEnabled() ||
+            streamingState !== StreamingState.Idle ||
+            !isMcpReady ||
+            isToolAwaitingConfirmation(pendingHistoryItems)) {
+            return;
+        }
+        const pendingHint = consumePendingHints();
+        if (!pendingHint) {
+            return;
+        }
+        void submitQuery([{ text: buildUserSteeringHintPrompt(pendingHint) }]);
+    }, [
+        config,
+        historyManager,
+        isConfigInitialized,
+        isMcpReady,
+        streamingState,
+        submitQuery,
+        consumePendingHints,
+        pendingHistoryItems,
+        pendingHintCount,
+    ]);
+    const allToolCalls = useMemo(() => getAllToolCalls(pendingHistoryItems), [pendingHistoryItems]);
+    const [geminiMdFileCount, setGeminiMdFileCount] = useState(config.getGeminiMdFileCount());
+    useEffect(() => {
+        const handleMemoryChanged = (result) => {
+            setGeminiMdFileCount(result.fileCount);
+        };
+        coreEvents.on(CoreEvent.MemoryChanged, handleMemoryChanged);
+        return () => {
+            coreEvents.off(CoreEvent.MemoryChanged, handleMemoryChanged);
+        };
+    }, []);
+    useEffect(() => {
+        let isMounted = true;
+        const fetchBannerTexts = async () => {
+            const [defaultBanner, warningBanner] = await Promise.all([
+                config.getBannerTextNoCapacityIssues(),
+                config.getBannerTextCapacityIssues(),
+            ]);
+            if (isMounted) {
+                setDefaultBannerText(defaultBanner);
+                setWarningBannerText(warningBanner);
+                setBannerVisible(true);
+            }
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        fetchBannerTexts();
+        return () => {
+            isMounted = false;
+        };
+    }, [config, refreshStatic]);
+    const inputState = useMemo(() => ({
+        buffer,
+        userMessages: inputHistory,
+        shellModeActive,
+        showEscapePrompt,
+        copyModeEnabled,
+        inputWidth,
+        suggestionsWidth,
+    }), [
+        buffer,
+        inputHistory,
+        shellModeActive,
+        showEscapePrompt,
+        copyModeEnabled,
+        inputWidth,
+        suggestionsWidth,
+    ]);
+    const quotaState = useMemo(() => ({
+        userTier,
+        stats: quotaStats,
+        proQuotaRequest,
+        validationRequest,
+        // G1 AI Credits dialog state
+        overageMenuRequest,
+        emptyWalletRequest,
+    }), [
+        userTier,
+        quotaStats,
+        proQuotaRequest,
+        validationRequest,
+        overageMenuRequest,
+        emptyWalletRequest,
+    ]);
+    const uiState = useMemo(() => ({
+        history: historyManager.history,
+        historyManager,
+        isThemeDialogOpen,
+        themeError,
+        isAuthenticating,
+        isConfigInitialized,
+        authError,
+        accountSuspensionInfo,
+        isAuthDialogOpen,
+        isAwaitingApiKeyInput: authState === AuthState.AwaitingApiKeyInput,
+        isAwaitingLoginRestart,
+        loginRestartMessage,
+        apiKeyDefaultValue,
+        editorError,
+        isEditorDialogOpen,
+        showPrivacyNotice,
+        mouseMode,
+        corgiMode,
+        debugMessage,
+        quittingMessages,
+        isSettingsDialogOpen,
+        isSessionBrowserOpen,
+        isModelDialogOpen,
+        isVoiceModelDialogOpen,
+        isAgentConfigDialogOpen,
+        selectedAgentName,
+        selectedAgentDisplayName,
+        selectedAgentDefinition,
+        isPermissionsDialogOpen,
+        permissionsDialogProps,
+        slashCommands,
+        pendingSlashCommandHistoryItems,
+        commandContext,
+        commandConfirmationRequest,
+        authConsentRequest,
+        confirmUpdateExtensionRequests,
+        loopDetectionConfirmationRequest,
+        permissionConfirmationRequest,
+        geminiMdFileCount,
+        streamingState,
+        initError,
+        pendingGeminiHistoryItems,
+        thought,
+        isInputActive,
+        isVoiceModeEnabled,
+        isResuming,
+        shouldShowIdePrompt,
+        isFolderTrustDialogOpen: isFolderTrustDialogOpen ?? false,
+        folderDiscoveryResults,
+        isPolicyUpdateDialogOpen,
+        policyUpdateConfirmationRequest,
+        isTrustedFolder,
+        constrainHeight,
+        showErrorDetails,
+        showFullTodos,
+        ideContextState,
+        renderMarkdown,
+        ctrlCPressedOnce: ctrlCPressCount >= 1,
+        ctrlDPressedOnce: ctrlDPressCount >= 1,
+        shortcutsHelpVisible,
+        cleanUiDetailsVisible,
+        isFocused,
+        elapsedTime,
+        currentLoadingPhrase,
+        currentTip,
+        currentWittyPhrase,
+        historyRemountKey,
+        activeHooks,
+        messageQueue,
+        queueErrorMessage,
+        showApprovalModeIndicator,
+        allowPlanMode,
+        currentModel,
+        contextFileNames,
+        errorCount,
+        availableTerminalHeight,
+        stableControlsHeight,
+        mainAreaWidth,
+        staticAreaMaxItemHeight,
+        staticExtraHeight,
+        dialogsVisible,
+        pendingHistoryItems,
+        nightly,
+        branchName,
+        sessionStats,
+        terminalWidth,
+        terminalHeight,
+        mainControlsRef,
+        rootUiRef,
+        currentIDE,
+        updateInfo,
+        showIdeRestartPrompt,
+        ideTrustRestartReason,
+        isRestarting,
+        extensionsUpdateState,
+        activePtyId,
+        backgroundTaskCount,
+        isBackgroundTaskVisible,
+        embeddedShellFocused,
+        showDebugProfiler,
+        customDialog,
+        transientMessage,
+        bannerData,
+        bannerVisible,
+        terminalBackgroundColor: config.getTerminalBackground(),
+        settingsNonce,
+        backgroundTasks,
+        activeBackgroundTaskPid,
+        backgroundTaskHeight,
+        isBackgroundTaskListOpen,
+        adminSettingsChanged,
+        newAgents,
+        showIsExpandableHint,
+        hintMode: config.isModelSteeringEnabled() && isToolExecuting(pendingHistoryItems),
+        hintBuffer: '',
+    }), [
+        isThemeDialogOpen,
+        themeError,
+        isAuthenticating,
+        isConfigInitialized,
+        authError,
+        accountSuspensionInfo,
+        isAuthDialogOpen,
+        editorError,
+        isEditorDialogOpen,
+        showPrivacyNotice,
+        mouseMode,
+        corgiMode,
+        debugMessage,
+        quittingMessages,
+        isSettingsDialogOpen,
+        isSessionBrowserOpen,
+        isModelDialogOpen,
+        isVoiceModelDialogOpen,
+        isAgentConfigDialogOpen,
+        selectedAgentName,
+        selectedAgentDisplayName,
+        selectedAgentDefinition,
+        isPermissionsDialogOpen,
+        permissionsDialogProps,
+        slashCommands,
+        pendingSlashCommandHistoryItems,
+        commandContext,
+        commandConfirmationRequest,
+        authConsentRequest,
+        confirmUpdateExtensionRequests,
+        loopDetectionConfirmationRequest,
+        permissionConfirmationRequest,
+        geminiMdFileCount,
+        streamingState,
+        initError,
+        pendingGeminiHistoryItems,
+        thought,
+        isInputActive,
+        isVoiceModeEnabled,
+        isResuming,
+        shouldShowIdePrompt,
+        isFolderTrustDialogOpen,
+        folderDiscoveryResults,
+        isPolicyUpdateDialogOpen,
+        policyUpdateConfirmationRequest,
+        isTrustedFolder,
+        constrainHeight,
+        showErrorDetails,
+        showFullTodos,
+        ideContextState,
+        renderMarkdown,
+        ctrlCPressCount,
+        ctrlDPressCount,
+        shortcutsHelpVisible,
+        cleanUiDetailsVisible,
+        isFocused,
+        elapsedTime,
+        currentLoadingPhrase,
+        currentTip,
+        currentWittyPhrase,
+        historyRemountKey,
+        activeHooks,
+        messageQueue,
+        queueErrorMessage,
+        showApprovalModeIndicator,
+        allowPlanMode,
+        contextFileNames,
+        errorCount,
+        availableTerminalHeight,
+        stableControlsHeight,
+        mainAreaWidth,
+        staticAreaMaxItemHeight,
+        staticExtraHeight,
+        dialogsVisible,
+        pendingHistoryItems,
+        nightly,
+        branchName,
+        sessionStats,
+        terminalWidth,
+        terminalHeight,
+        mainControlsRef,
+        rootUiRef,
+        currentIDE,
+        updateInfo,
+        showIdeRestartPrompt,
+        ideTrustRestartReason,
+        isRestarting,
+        currentModel,
+        extensionsUpdateState,
+        activePtyId,
+        backgroundTaskCount,
+        isBackgroundTaskVisible,
+        historyManager,
+        embeddedShellFocused,
+        showDebugProfiler,
+        customDialog,
+        apiKeyDefaultValue,
+        authState,
+        isAwaitingLoginRestart,
+        loginRestartMessage,
+        transientMessage,
+        bannerData,
+        bannerVisible,
+        config,
+        settingsNonce,
+        backgroundTaskHeight,
+        isBackgroundTaskListOpen,
+        activeBackgroundTaskPid,
+        backgroundTasks,
+        adminSettingsChanged,
+        newAgents,
+        showIsExpandableHint,
+    ]);
+    const exitPrivacyNotice = useCallback(() => setShowPrivacyNotice(false), [setShowPrivacyNotice]);
+    const uiActions = useMemo(() => ({
+        handleThemeSelect,
+        closeThemeDialog,
+        handleThemeHighlight,
+        handleAuthSelect,
+        setAuthState,
+        onAuthError,
+        handleEditorSelect,
+        exitEditorDialog,
+        exitPrivacyNotice,
+        closeSettingsDialog,
+        closeModelDialog,
+        openVoiceModelDialog,
+        closeVoiceModelDialog,
+        openAgentConfigDialog,
+        closeAgentConfigDialog,
+        openPermissionsDialog,
+        closePermissionsDialog,
+        setShellModeActive,
+        vimHandleInput,
+        handleIdePromptComplete,
+        handleFolderTrustSelect,
+        setIsPolicyUpdateDialogOpen,
+        setConstrainHeight,
+        onEscapePromptChange: handleEscapePromptChange,
+        refreshStatic,
+        handleFinalSubmit,
+        handleClearScreen,
+        handleProQuotaChoice,
+        handleValidationChoice,
+        // G1 AI Credits handlers
+        handleOverageMenuChoice,
+        handleEmptyWalletChoice,
+        openSessionBrowser,
+        closeSessionBrowser,
+        handleResumeSession,
+        handleDeleteSession,
+        setQueueErrorMessage,
+        addMessage,
+        popAllMessages,
+        handleApiKeySubmit,
+        handleApiKeyCancel,
+        setBannerVisible,
+        setShortcutsHelpVisible,
+        setCleanUiDetailsVisible,
+        toggleCleanUiDetailsVisible,
+        revealCleanUiDetailsTemporarily,
+        handleWarning,
+        setEmbeddedShellFocused,
+        dismissBackgroundTask,
+        setActiveBackgroundTaskPid,
+        setIsBackgroundTaskListOpen,
+        setAuthContext,
+        dismissLoginRestart: () => {
+            setAuthContext({});
+            setAuthState(AuthState.Updating);
+        },
+        onHintInput: () => { },
+        onHintBackspace: () => { },
+        onHintClear: () => { },
+        onHintSubmit: () => { },
+        handleRestart: async () => {
+            if (process.send) {
+                const remoteSettings = config.getRemoteAdminSettings();
+                if (remoteSettings) {
+                    process.send({
+                        type: 'admin-settings-update',
+                        settings: remoteSettings,
+                    });
+                }
+            }
+            await relaunchApp();
+        },
+        handleNewAgentsSelect: async (choice) => {
+            if (newAgents && choice === NewAgentsChoice.ACKNOWLEDGE) {
+                const registry = config.getAgentRegistry();
+                try {
+                    await Promise.all(newAgents.map((agent) => registry.acknowledgeAgent(agent)));
+                }
+                catch (error) {
+                    debugLogger.error('Failed to acknowledge agents:', error);
+                    historyManager.addItem({
+                        type: MessageType.ERROR,
+                        text: `Failed to acknowledge agents: ${getErrorMessage(error)}`,
+                    }, Date.now());
+                }
+            }
+            setNewAgents(null);
+        },
+        getPreferredEditor,
+        clearAccountSuspension: () => {
+            setAccountSuspensionInfo(null);
+            setAuthState(AuthState.Updating);
+        },
+        setVoiceModeEnabled: (value) => {
+            setVoiceModeEnabled(value);
+        },
+    }), [
+        handleThemeSelect,
+        closeThemeDialog,
+        handleThemeHighlight,
+        handleAuthSelect,
+        setAuthState,
+        onAuthError,
+        handleEditorSelect,
+        exitEditorDialog,
+        exitPrivacyNotice,
+        closeSettingsDialog,
+        closeModelDialog,
+        openVoiceModelDialog,
+        closeVoiceModelDialog,
+        openAgentConfigDialog,
+        closeAgentConfigDialog,
+        openPermissionsDialog,
+        closePermissionsDialog,
+        setShellModeActive,
+        vimHandleInput,
+        handleIdePromptComplete,
+        handleFolderTrustSelect,
+        setIsPolicyUpdateDialogOpen,
+        setConstrainHeight,
+        handleEscapePromptChange,
+        refreshStatic,
+        handleFinalSubmit,
+        handleClearScreen,
+        handleProQuotaChoice,
+        handleValidationChoice,
+        handleOverageMenuChoice,
+        handleEmptyWalletChoice,
+        openSessionBrowser,
+        closeSessionBrowser,
+        handleResumeSession,
+        handleDeleteSession,
+        setQueueErrorMessage,
+        addMessage,
+        popAllMessages,
+        handleApiKeySubmit,
+        handleApiKeyCancel,
+        setBannerVisible,
+        setShortcutsHelpVisible,
+        setCleanUiDetailsVisible,
+        toggleCleanUiDetailsVisible,
+        revealCleanUiDetailsTemporarily,
+        handleWarning,
+        setEmbeddedShellFocused,
+        dismissBackgroundTask,
+        setActiveBackgroundTaskPid,
+        setIsBackgroundTaskListOpen,
+        setAuthContext,
+        setAccountSuspensionInfo,
+        newAgents,
+        config,
+        historyManager,
+        getPreferredEditor,
+        setVoiceModeEnabled,
+    ]);
+    return (_jsx(UIStateContext.Provider, { value: uiState, children: _jsx(QuotaContext.Provider, { value: quotaState, children: _jsx(InputContext.Provider, { value: inputState, children: _jsx(UIActionsContext.Provider, { value: uiActions, children: _jsx(ConfigContext.Provider, { value: config, children: _jsx(AppContext.Provider, { value: {
+                                version: props.version,
+                                startupWarnings: props.startupWarnings || [],
+                            }, children: _jsx(ToolActionsProvider, { config: config, toolCalls: allToolCalls, isExpanded: isExpanded, toggleExpansion: toggleExpansion, toggleAllExpansion: toggleAllExpansion, children: _jsx(ShellFocusContext.Provider, { value: isFocused, children: _jsx(MouseProvider, { mouseEventsEnabled: mouseMode, children: _jsx(ScrollProvider, { children: _jsx(App, {}) }) }) }) }) }) }) }) }) }) }));
+};
+//# sourceMappingURL=AppContainer.js.map