@didim365/agent-cli 0.1.1 → 0.1.2

package/dist/src/ui/AppContainer.test.js

@@ -1,2072 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { render } from '../test-utils/render.js';
-import { waitFor } from '../test-utils/async.js';
-import { cleanup } from 'ink-testing-library';
-import { act, useContext } from 'react';
-import { AppContainer } from './AppContainer.js';
-import { SettingsContext } from './contexts/SettingsContext.js';
-import {} from './hooks/useReactToolScheduler.js';
-import { makeFakeConfig, CoreEvent, AuthType, } from '@didim365/agent-cli-core';
-// Mock coreEvents
-const mockCoreEvents = vi.hoisted(() => ({
-    on: vi.fn(),
-    off: vi.fn(),
-    drainBacklogs: vi.fn(),
-    emit: vi.fn(),
-}));
-// Mock IdeClient
-const mockIdeClient = vi.hoisted(() => ({
-    getInstance: vi.fn().mockReturnValue(new Promise(() => { })),
-}));
-// Mock stdout
-const mocks = vi.hoisted(() => ({
-    mockStdout: { write: vi.fn() },
-}));
-vi.mock('@didim365/agent-cli-core', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        coreEvents: mockCoreEvents,
-        IdeClient: mockIdeClient,
-        writeToStdout: vi.fn((...args) => process.stdout.write(...args)),
-        writeToStderr: vi.fn((...args) => process.stderr.write(...args)),
-        patchStdio: vi.fn(() => () => { }),
-        createWorkingStdio: vi.fn(() => ({
-            stdout: process.stdout,
-            stderr: process.stderr,
-        })),
-        enableMouseEvents: vi.fn(),
-        disableMouseEvents: vi.fn(),
-        FileDiscoveryService: vi.fn().mockImplementation(() => ({
-            initialize: vi.fn(),
-        })),
-        startupProfiler: {
-            flush: vi.fn(),
-            start: vi.fn(),
-            end: vi.fn(),
-        },
-    };
-});
-import ansiEscapes from 'ansi-escapes';
-import { mergeSettings } from '../config/settings.js';
-import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
-import { UIStateContext } from './contexts/UIStateContext.js';
-import { UIActionsContext, } from './contexts/UIActionsContext.js';
-// Mock useStdout to capture terminal title writes
-vi.mock('ink', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        useStdout: () => ({ stdout: mocks.mockStdout }),
-        measureElement: vi.fn(),
-    };
-});
-// Helper component will read the context values provided by AppContainer
-// so we can assert against them in our tests.
-let capturedUIState;
-let capturedUIActions;
-function TestContextConsumer() {
-    capturedUIState = useContext(UIStateContext);
-    capturedUIActions = useContext(UIActionsContext);
-    return null;
-}
-vi.mock('./App.js', () => ({
-    App: TestContextConsumer,
-}));
-vi.mock('./hooks/useQuotaAndFallback.js');
-vi.mock('./hooks/useHistoryManager.js');
-vi.mock('./hooks/useThemeCommand.js');
-vi.mock('./auth/useAuth.js');
-vi.mock('./hooks/useEditorSettings.js');
-vi.mock('./hooks/useSettingsCommand.js');
-vi.mock('./hooks/useModelCommand.js');
-vi.mock('./hooks/slashCommandProcessor.js');
-vi.mock('./hooks/useConsoleMessages.js');
-vi.mock('./hooks/useTerminalSize.js', () => ({
-    useTerminalSize: vi.fn(() => ({ columns: 80, rows: 24 })),
-}));
-vi.mock('./hooks/useGeminiStream.js');
-vi.mock('./hooks/vim.js');
-vi.mock('./hooks/useFocus.js');
-vi.mock('./hooks/useBracketedPaste.js');
-vi.mock('./hooks/useKeypress.js');
-vi.mock('./hooks/useLoadingIndicator.js');
-vi.mock('./hooks/useFolderTrust.js');
-vi.mock('./hooks/useIdeTrustListener.js');
-vi.mock('./hooks/useMessageQueue.js');
-vi.mock('./hooks/useApprovalModeIndicator.js');
-vi.mock('./hooks/useGitBranchName.js');
-vi.mock('./contexts/VimModeContext.js');
-vi.mock('./contexts/SessionContext.js');
-vi.mock('./components/shared/text-buffer.js');
-vi.mock('./hooks/useLogger.js');
-vi.mock('./hooks/useInputHistoryStore.js');
-vi.mock('./hooks/useHookDisplayState.js');
-// Mock external utilities
-vi.mock('../utils/events.js');
-vi.mock('../utils/handleAutoUpdate.js');
-vi.mock('./utils/ConsolePatcher.js');
-vi.mock('../utils/cleanup.js');
-import { useHistory } from './hooks/useHistoryManager.js';
-import { useThemeCommand } from './hooks/useThemeCommand.js';
-import { useAuthCommand } from './auth/useAuth.js';
-import { useEditorSettings } from './hooks/useEditorSettings.js';
-import { useSettingsCommand } from './hooks/useSettingsCommand.js';
-import { useModelCommand } from './hooks/useModelCommand.js';
-import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
-import { useConsoleMessages } from './hooks/useConsoleMessages.js';
-import { useGeminiStream } from './hooks/useGeminiStream.js';
-import { useVim } from './hooks/vim.js';
-import { useFolderTrust } from './hooks/useFolderTrust.js';
-import { useIdeTrustListener } from './hooks/useIdeTrustListener.js';
-import { useMessageQueue } from './hooks/useMessageQueue.js';
-import { useApprovalModeIndicator } from './hooks/useApprovalModeIndicator.js';
-import { useGitBranchName } from './hooks/useGitBranchName.js';
-import { useVimMode } from './contexts/VimModeContext.js';
-import { useSessionStats } from './contexts/SessionContext.js';
-import { useTextBuffer } from './components/shared/text-buffer.js';
-import { useLogger } from './hooks/useLogger.js';
-import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
-import { useInputHistoryStore } from './hooks/useInputHistoryStore.js';
-import { useHookDisplayState } from './hooks/useHookDisplayState.js';
-import { useKeypress } from './hooks/useKeypress.js';
-import { measureElement } from 'ink';
-import { useTerminalSize } from './hooks/useTerminalSize.js';
-import { ShellExecutionService, writeToStdout, enableMouseEvents, disableMouseEvents, } from '@didim365/agent-cli-core';
-import {} from '../config/extension-manager.js';
-describe('AppContainer State Management', () => {
-    let mockConfig;
-    let mockSettings;
-    let mockInitResult;
-    let mockExtensionManager;
-    // Helper to generate the AppContainer JSX for render and rerender
-    const getAppContainer = ({ settings = mockSettings, config = mockConfig, version = '1.0.0', initResult = mockInitResult, startupWarnings, resumedSessionData, } = {}) => (_jsx(SettingsContext.Provider, { value: settings, children: _jsx(AppContainer, { config: config, version: version, initializationResult: initResult, startupWarnings: startupWarnings, resumedSessionData: resumedSessionData }) }));
-    // Helper to render the AppContainer
-    const renderAppContainer = (props) => render(getAppContainer(props));
-    // Create typed mocks for all hooks
-    const mockedUseQuotaAndFallback = useQuotaAndFallback;
-    const mockedUseHistory = useHistory;
-    const mockedUseThemeCommand = useThemeCommand;
-    const mockedUseAuthCommand = useAuthCommand;
-    const mockedUseEditorSettings = useEditorSettings;
-    const mockedUseSettingsCommand = useSettingsCommand;
-    const mockedUseModelCommand = useModelCommand;
-    const mockedUseSlashCommandProcessor = useSlashCommandProcessor;
-    const mockedUseConsoleMessages = useConsoleMessages;
-    const mockedUseGeminiStream = useGeminiStream;
-    const mockedUseVim = useVim;
-    const mockedUseFolderTrust = useFolderTrust;
-    const mockedUseIdeTrustListener = useIdeTrustListener;
-    const mockedUseMessageQueue = useMessageQueue;
-    const mockedUseApprovalModeIndicator = useApprovalModeIndicator;
-    const mockedUseGitBranchName = useGitBranchName;
-    const mockedUseVimMode = useVimMode;
-    const mockedUseSessionStats = useSessionStats;
-    const mockedUseTextBuffer = useTextBuffer;
-    const mockedUseLogger = useLogger;
-    const mockedUseLoadingIndicator = useLoadingIndicator;
-    const mockedUseKeypress = useKeypress;
-    const mockedUseInputHistoryStore = useInputHistoryStore;
-    const mockedUseHookDisplayState = useHookDisplayState;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockIdeClient.getInstance.mockReturnValue(new Promise(() => { }));
-        // Initialize mock stdout for terminal title tests
-        mocks.mockStdout.write.mockClear();
-        capturedUIState = null;
-        // **Provide a default return value for EVERY mocked hook.**
-        mockedUseQuotaAndFallback.mockReturnValue({
-            proQuotaRequest: null,
-            handleProQuotaChoice: vi.fn(),
-        });
-        mockedUseHistory.mockReturnValue({
-            history: [],
-            addItem: vi.fn(),
-            updateItem: vi.fn(),
-            clearItems: vi.fn(),
-            loadHistory: vi.fn(),
-        });
-        mockedUseThemeCommand.mockReturnValue({
-            isThemeDialogOpen: false,
-            openThemeDialog: vi.fn(),
-            handleThemeSelect: vi.fn(),
-            handleThemeHighlight: vi.fn(),
-        });
-        mockedUseAuthCommand.mockReturnValue({
-            authState: 'authenticated',
-            setAuthState: vi.fn(),
-            authError: null,
-            onAuthError: vi.fn(),
-        });
-        mockedUseEditorSettings.mockReturnValue({
-            isEditorDialogOpen: false,
-            openEditorDialog: vi.fn(),
-            handleEditorSelect: vi.fn(),
-            exitEditorDialog: vi.fn(),
-        });
-        mockedUseSettingsCommand.mockReturnValue({
-            isSettingsDialogOpen: false,
-            openSettingsDialog: vi.fn(),
-            closeSettingsDialog: vi.fn(),
-        });
-        mockedUseModelCommand.mockReturnValue({
-            isModelDialogOpen: false,
-            openModelDialog: vi.fn(),
-            closeModelDialog: vi.fn(),
-        });
-        mockedUseSlashCommandProcessor.mockReturnValue({
-            handleSlashCommand: vi.fn(),
-            slashCommands: [],
-            pendingHistoryItems: [],
-            commandContext: {},
-            shellConfirmationRequest: null,
-            confirmationRequest: null,
-        });
-        mockedUseConsoleMessages.mockReturnValue({
-            consoleMessages: [],
-            handleNewMessage: vi.fn(),
-            clearConsoleMessages: vi.fn(),
-        });
-        mockedUseGeminiStream.mockReturnValue({
-            streamingState: 'idle',
-            submitQuery: vi.fn(),
-            initError: null,
-            pendingHistoryItems: [],
-            thought: null,
-            cancelOngoingRequest: vi.fn(),
-        });
-        mockedUseVim.mockReturnValue({ handleInput: vi.fn() });
-        mockedUseFolderTrust.mockReturnValue({
-            isFolderTrustDialogOpen: false,
-            handleFolderTrustSelect: vi.fn(),
-            isRestarting: false,
-        });
-        mockedUseIdeTrustListener.mockReturnValue({
-            needsRestart: false,
-            restartReason: 'NONE',
-        });
-        mockedUseMessageQueue.mockReturnValue({
-            messageQueue: [],
-            addMessage: vi.fn(),
-            clearQueue: vi.fn(),
-            getQueuedMessagesText: vi.fn().mockReturnValue(''),
-        });
-        mockedUseApprovalModeIndicator.mockReturnValue(false);
-        mockedUseGitBranchName.mockReturnValue('main');
-        mockedUseVimMode.mockReturnValue({
-            isVimEnabled: false,
-            toggleVimEnabled: vi.fn(),
-        });
-        mockedUseSessionStats.mockReturnValue({ stats: {} });
-        mockedUseTextBuffer.mockReturnValue({
-            text: '',
-            setText: vi.fn(),
-            // Add other properties if AppContainer uses them
-        });
-        mockedUseLogger.mockReturnValue({
-            getPreviousUserMessages: vi.fn().mockResolvedValue([]),
-        });
-        mockedUseInputHistoryStore.mockReturnValue({
-            inputHistory: [],
-            addInput: vi.fn(),
-            initializeFromLogger: vi.fn(),
-        });
-        mockedUseLoadingIndicator.mockReturnValue({
-            elapsedTime: '0.0s',
-            currentLoadingPhrase: '',
-        });
-        mockedUseHookDisplayState.mockReturnValue([]);
-        // Mock Config
-        mockConfig = makeFakeConfig();
-        // Mock config's getTargetDir to return consistent workspace directory
-        vi.spyOn(mockConfig, 'getTargetDir').mockReturnValue('/test/workspace');
-        vi.spyOn(mockConfig, 'initialize').mockResolvedValue(undefined);
-        vi.spyOn(mockConfig, 'getDebugMode').mockReturnValue(false);
-        mockExtensionManager = vi.mockObject({
-            getExtensions: vi.fn().mockReturnValue([]),
-            setRequestConsent: vi.fn(),
-            setRequestSetting: vi.fn(),
-            start: vi.fn(),
-        });
-        vi.spyOn(mockConfig, 'getExtensionLoader').mockReturnValue(mockExtensionManager);
-        // Mock LoadedSettings
-        const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-        mockSettings = {
-            merged: {
-                ...defaultMergedSettings,
-                hideBanner: false,
-                hideFooter: false,
-                hideTips: false,
-                showMemoryUsage: false,
-                theme: 'default',
-                ui: {
-                    ...defaultMergedSettings.ui,
-                    showStatusInTitle: false,
-                    hideWindowTitle: false,
-                },
-                useAlternateBuffer: false,
-            },
-        };
-        // Mock InitializationResult
-        mockInitResult = {
-            themeError: null,
-            authError: null,
-            shouldOpenAuthDialog: false,
-            geminiMdFileCount: 0,
-        };
-    });
-    afterEach(() => {
-        cleanup();
-        vi.restoreAllMocks();
-    });
-    describe('Basic Rendering', () => {
-        it('renders without crashing with minimal props', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-        it('renders with startup warnings', async () => {
-            const startupWarnings = ['Warning 1', 'Warning 2'];
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({ startupWarnings });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-    });
-    describe('State Initialization', () => {
-        it('initializes with theme error from initialization result', async () => {
-            const initResultWithError = {
-                ...mockInitResult,
-                themeError: 'Failed to load theme',
-            };
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({
-                    initResult: initResultWithError,
-                });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-        it('handles debug mode state', () => {
-            const debugConfig = makeFakeConfig();
-            vi.spyOn(debugConfig, 'getDebugMode').mockReturnValue(true);
-            expect(() => {
-                renderAppContainer({ config: debugConfig });
-            }).not.toThrow();
-        });
-    });
-    describe('Context Providers', () => {
-        it('provides AppContext with correct values', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({ version: '2.0.0' });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            // Should render and unmount cleanly
-            expect(() => unmount()).not.toThrow();
-        });
-        it('provides UIStateContext with state management', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-        it('provides UIActionsContext with action handlers', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-        it('provides ConfigContext with config object', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-    });
-    describe('Settings Integration', () => {
-        it('handles settings with all display options disabled', async () => {
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const settingsAllHidden = {
-                merged: {
-                    ...defaultMergedSettings,
-                    hideBanner: true,
-                    hideFooter: true,
-                    hideTips: true,
-                    showMemoryUsage: false,
-                },
-            };
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({ settings: settingsAllHidden });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-        it('handles settings with memory usage enabled', async () => {
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const settingsWithMemory = {
-                merged: {
-                    ...defaultMergedSettings,
-                    hideBanner: false,
-                    hideFooter: false,
-                    hideTips: false,
-                    showMemoryUsage: true,
-                },
-            };
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({ settings: settingsWithMemory });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-    });
-    describe('Version Handling', () => {
-        it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', async (version) => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({ version });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-    });
-    describe('Error Handling', () => {
-        it('handles config methods that might throw', async () => {
-            const errorConfig = makeFakeConfig();
-            vi.spyOn(errorConfig, 'getModel').mockImplementation(() => {
-                throw new Error('Config error');
-            });
-            // Should still render without crashing - errors should be handled internally
-            const { unmount } = renderAppContainer({ config: errorConfig });
-            unmount();
-        });
-        it('handles undefined settings gracefully', async () => {
-            const undefinedSettings = {
-                merged: mergeSettings({}, {}, {}, {}, true),
-            };
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({ settings: undefinedSettings });
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-        });
-    });
-    describe('Provider Hierarchy', () => {
-        it('establishes correct provider nesting order', () => {
-            // This tests that all the context providers are properly nested
-            // and that the component tree can be built without circular dependencies
-            const { unmount } = renderAppContainer();
-            expect(() => unmount()).not.toThrow();
-        });
-    });
-    describe('Session Resumption', () => {
-        it('handles resumed session data correctly', async () => {
-            const mockResumedSessionData = {
-                conversation: {
-                    sessionId: 'test-session-123',
-                    projectHash: 'test-project-hash',
-                    startTime: '2024-01-01T00:00:00Z',
-                    lastUpdated: '2024-01-01T00:00:01Z',
-                    messages: [
-                        {
-                            id: 'msg-1',
-                            type: 'user',
-                            content: 'Hello',
-                            timestamp: '2024-01-01T00:00:00Z',
-                        },
-                        {
-                            id: 'msg-2',
-                            type: 'gemini',
-                            content: 'Hi there!',
-                            role: 'model',
-                            parts: [{ text: 'Hi there!' }],
-                            timestamp: '2024-01-01T00:00:01Z',
-                        },
-                    ],
-                },
-                filePath: '/tmp/test-session.json',
-            };
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({
-                    config: mockConfig,
-                    settings: mockSettings,
-                    version: '1.0.0',
-                    initResult: mockInitResult,
-                    resumedSessionData: mockResumedSessionData,
-                });
-                unmount = result.unmount;
-            });
-            await act(async () => {
-                unmount();
-            });
-        });
-        it('renders without resumed session data', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({
-                    config: mockConfig,
-                    settings: mockSettings,
-                    version: '1.0.0',
-                    initResult: mockInitResult,
-                    resumedSessionData: undefined,
-                });
-                unmount = result.unmount;
-            });
-            await act(async () => {
-                unmount();
-            });
-        });
-        it('initializes chat recording service when config has it', () => {
-            const mockChatRecordingService = {
-                initialize: vi.fn(),
-                recordMessage: vi.fn(),
-                recordMessageTokens: vi.fn(),
-                recordToolCalls: vi.fn(),
-            };
-            const mockGeminiClient = {
-                isInitialized: vi.fn(() => true),
-                resumeChat: vi.fn(),
-                getUserTier: vi.fn(),
-                getChatRecordingService: vi.fn(() => mockChatRecordingService),
-            };
-            const configWithRecording = {
-                ...mockConfig,
-                getGeminiClient: vi.fn(() => mockGeminiClient),
-            };
-            expect(() => {
-                renderAppContainer({
-                    config: configWithRecording,
-                    settings: mockSettings,
-                    version: '1.0.0',
-                    initResult: mockInitResult,
-                });
-            }).not.toThrow();
-        });
-    });
-    describe('Session Recording Integration', () => {
-        it('provides chat recording service configuration', () => {
-            const mockChatRecordingService = {
-                initialize: vi.fn(),
-                recordMessage: vi.fn(),
-                recordMessageTokens: vi.fn(),
-                recordToolCalls: vi.fn(),
-                getSessionId: vi.fn(() => 'test-session-123'),
-                getCurrentConversation: vi.fn(),
-            };
-            const mockGeminiClient = {
-                isInitialized: vi.fn(() => true),
-                resumeChat: vi.fn(),
-                getUserTier: vi.fn(),
-                getChatRecordingService: vi.fn(() => mockChatRecordingService),
-                setHistory: vi.fn(),
-            };
-            const configWithRecording = {
-                ...mockConfig,
-                getGeminiClient: vi.fn(() => mockGeminiClient),
-                getSessionId: vi.fn(() => 'test-session-123'),
-            };
-            expect(() => {
-                renderAppContainer({
-                    config: configWithRecording,
-                    settings: mockSettings,
-                    version: '1.0.0',
-                    initResult: mockInitResult,
-                });
-            }).not.toThrow();
-            // Verify the recording service structure is correct
-            expect(configWithRecording.getGeminiClient).toBeDefined();
-            expect(mockGeminiClient.getChatRecordingService).toBeDefined();
-            expect(mockChatRecordingService.initialize).toBeDefined();
-            expect(mockChatRecordingService.recordMessage).toBeDefined();
-        });
-        it('handles session recording when messages are added', () => {
-            const mockRecordMessage = vi.fn();
-            const mockRecordMessageTokens = vi.fn();
-            const mockChatRecordingService = {
-                initialize: vi.fn(),
-                recordMessage: mockRecordMessage,
-                recordMessageTokens: mockRecordMessageTokens,
-                recordToolCalls: vi.fn(),
-                getSessionId: vi.fn(() => 'test-session-123'),
-            };
-            const mockGeminiClient = {
-                isInitialized: vi.fn(() => true),
-                getChatRecordingService: vi.fn(() => mockChatRecordingService),
-                getUserTier: vi.fn(),
-            };
-            const configWithRecording = {
-                ...mockConfig,
-                getGeminiClient: vi.fn(() => mockGeminiClient),
-            };
-            renderAppContainer({
-                config: configWithRecording,
-                settings: mockSettings,
-                version: '1.0.0',
-                initResult: mockInitResult,
-            });
-            // The actual recording happens through the useHistory hook
-            // which would be triggered by user interactions
-            expect(mockChatRecordingService.initialize).toBeDefined();
-            expect(mockChatRecordingService.recordMessage).toBeDefined();
-        });
-    });
-    describe('Session Resume Flow', () => {
-        it('accepts resumed session data', () => {
-            const mockResumeChat = vi.fn();
-            const mockGeminiClient = {
-                isInitialized: vi.fn(() => true),
-                resumeChat: mockResumeChat,
-                getUserTier: vi.fn(),
-                getChatRecordingService: vi.fn(() => ({
-                    initialize: vi.fn(),
-                    recordMessage: vi.fn(),
-                    recordMessageTokens: vi.fn(),
-                    recordToolCalls: vi.fn(),
-                })),
-            };
-            const configWithClient = {
-                ...mockConfig,
-                getGeminiClient: vi.fn(() => mockGeminiClient),
-            };
-            const resumedData = {
-                conversation: {
-                    sessionId: 'resumed-session-456',
-                    projectHash: 'project-hash',
-                    startTime: '2024-01-01T00:00:00Z',
-                    lastUpdated: '2024-01-01T00:01:00Z',
-                    messages: [
-                        {
-                            id: 'msg-1',
-                            type: 'user',
-                            content: 'Previous question',
-                            timestamp: '2024-01-01T00:00:00Z',
-                        },
-                        {
-                            id: 'msg-2',
-                            type: 'gemini',
-                            content: 'Previous answer',
-                            role: 'model',
-                            parts: [{ text: 'Previous answer' }],
-                            timestamp: '2024-01-01T00:00:30Z',
-                            tokenCount: { input: 10, output: 20 },
-                        },
-                    ],
-                },
-                filePath: '/tmp/resumed-session.json',
-            };
-            expect(() => {
-                renderAppContainer({
-                    config: configWithClient,
-                    settings: mockSettings,
-                    version: '1.0.0',
-                    initResult: mockInitResult,
-                    resumedSessionData: resumedData,
-                });
-            }).not.toThrow();
-            // Verify the resume functionality structure is in place
-            expect(mockGeminiClient.resumeChat).toBeDefined();
-            expect(resumedData.conversation.messages).toHaveLength(2);
-        });
-        it('does not attempt resume when client is not initialized', () => {
-            const mockResumeChat = vi.fn();
-            const mockGeminiClient = {
-                isInitialized: vi.fn(() => false), // Not initialized
-                resumeChat: mockResumeChat,
-                getUserTier: vi.fn(),
-                getChatRecordingService: vi.fn(),
-            };
-            const configWithClient = {
-                ...mockConfig,
-                getGeminiClient: vi.fn(() => mockGeminiClient),
-            };
-            const resumedData = {
-                conversation: {
-                    sessionId: 'test-session',
-                    projectHash: 'project-hash',
-                    startTime: '2024-01-01T00:00:00Z',
-                    lastUpdated: '2024-01-01T00:01:00Z',
-                    messages: [],
-                },
-                filePath: '/tmp/session.json',
-            };
-            renderAppContainer({
-                config: configWithClient,
-                settings: mockSettings,
-                version: '1.0.0',
-                initResult: mockInitResult,
-                resumedSessionData: resumedData,
-            });
-            // Should not call resumeChat when client is not initialized
-            expect(mockResumeChat).not.toHaveBeenCalled();
-        });
-    });
-    describe('Token Counting from Session Stats', () => {
-        it('tracks token counts from session messages', () => {
-            // Session stats are provided through the SessionStatsProvider context
-            // in the real app, not through the config directly
-            const mockChatRecordingService = {
-                initialize: vi.fn(),
-                recordMessage: vi.fn(),
-                recordMessageTokens: vi.fn(),
-                recordToolCalls: vi.fn(),
-                getSessionId: vi.fn(() => 'test-session-123'),
-                getCurrentConversation: vi.fn(() => ({
-                    sessionId: 'test-session-123',
-                    messages: [],
-                    totalInputTokens: 150,
-                    totalOutputTokens: 350,
-                })),
-            };
-            const mockGeminiClient = {
-                isInitialized: vi.fn(() => true),
-                getChatRecordingService: vi.fn(() => mockChatRecordingService),
-                getUserTier: vi.fn(),
-            };
-            const configWithRecording = {
-                ...mockConfig,
-                getGeminiClient: vi.fn(() => mockGeminiClient),
-            };
-            renderAppContainer({
-                config: configWithRecording,
-                settings: mockSettings,
-                version: '1.0.0',
-                initResult: mockInitResult,
-            });
-            // In the actual app, these stats would be displayed in components
-            // and updated as messages are processed through the recording service
-            expect(mockChatRecordingService.recordMessageTokens).toBeDefined();
-            expect(mockChatRecordingService.getCurrentConversation).toBeDefined();
-        });
-    });
-    describe('Quota and Fallback Integration', () => {
-        it('passes a null proQuotaRequest to UIStateContext by default', async () => {
-            // The default mock from beforeEach already sets proQuotaRequest to null
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => {
-                // Assert that the context value is as expected
-                expect(capturedUIState.proQuotaRequest).toBeNull();
-            });
-            unmount();
-        });
-        it('passes a valid proQuotaRequest to UIStateContext when provided by the hook', async () => {
-            // Arrange: Create a mock request object that a UI dialog would receive
-            const mockRequest = {
-                failedModel: 'gemini-pro',
-                fallbackModel: 'gemini-flash',
-                resolve: vi.fn(),
-            };
-            mockedUseQuotaAndFallback.mockReturnValue({
-                proQuotaRequest: mockRequest,
-                handleProQuotaChoice: vi.fn(),
-            });
-            // Act: Render the container
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => {
-                // Assert: The mock request is correctly passed through the context
-                expect(capturedUIState.proQuotaRequest).toEqual(mockRequest);
-            });
-            unmount();
-        });
-        it('passes the handleProQuotaChoice function to UIActionsContext', async () => {
-            // Arrange: Create a mock handler function
-            const mockHandler = vi.fn();
-            mockedUseQuotaAndFallback.mockReturnValue({
-                proQuotaRequest: null,
-                handleProQuotaChoice: mockHandler,
-            });
-            // Act: Render the container
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => {
-                // Assert: The action in the context is the mock handler we provided
-                expect(capturedUIActions.handleProQuotaChoice).toBe(mockHandler);
-            });
-            // You can even verify that the plumbed function is callable
-            act(() => {
-                capturedUIActions.handleProQuotaChoice('retry_later');
-            });
-            expect(mockHandler).toHaveBeenCalledWith('retry_later');
-            unmount();
-        });
-    });
-    describe('Terminal Title Update Feature', () => {
-        beforeEach(() => {
-            // Reset mock stdout for each test
-            mocks.mockStdout.write.mockClear();
-        });
-        it('verifies useStdout is mocked', async () => {
-            const { useStdout } = await import('ink');
-            const { stdout } = useStdout();
-            expect(stdout).toBe(mocks.mockStdout);
-        });
-        it('should update terminal title with Working… when showStatusInTitle is false', () => {
-            // Arrange: Set up mock settings with showStatusInTitle disabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithShowStatusFalse = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: false,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state as Active
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: { subject: 'Some thought' },
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithShowStatusFalse,
-            });
-            // Assert: Check that title was updated with "Working…"
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            expect(titleWrites[0][0]).toBe(`\x1b]0;${'✦  Working… (workspace)'.padEnd(80, ' ')}\x07`);
-            unmount();
-        });
-        it('should use legacy terminal title when dynamicWindowTitle is false', () => {
-            // Arrange: Set up mock settings with dynamicWindowTitle disabled
-            const mockSettingsWithDynamicTitleFalse = {
-                ...mockSettings,
-                merged: {
-                    ...mockSettings.merged,
-                    ui: {
-                        ...mockSettings.merged.ui,
-                        dynamicWindowTitle: false,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: { subject: 'Some thought' },
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithDynamicTitleFalse,
-            });
-            // Assert: Check that legacy title was used
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            expect(titleWrites[0][0]).toBe(`\x1b]0;${'Gemini CLI (workspace)'.padEnd(80, ' ')}\x07`);
-            unmount();
-        });
-        it('should not update terminal title when hideWindowTitle is true', () => {
-            // Arrange: Set up mock settings with hideWindowTitle enabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithHideTitleTrue = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: true,
-                        hideWindowTitle: true,
-                    },
-                },
-            };
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithHideTitleTrue,
-            });
-            // Assert: Check that no title-related writes occurred
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(0);
-            unmount();
-        });
-        it('should update terminal title with thought subject when in active state', () => {
-            // Arrange: Set up mock settings with showStatusInTitle enabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithTitleEnabled = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: true,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state and thought
-            const thoughtSubject = 'Processing request';
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: { subject: thoughtSubject },
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithTitleEnabled,
-            });
-            // Assert: Check that title was updated with thought subject and suffix
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            expect(titleWrites[0][0]).toBe(`\x1b]0;${`✦  ${thoughtSubject} (workspace)`.padEnd(80, ' ')}\x07`);
-            unmount();
-        });
-        it('should update terminal title with default text when in Idle state and no thought subject', () => {
-            // Arrange: Set up mock settings with showStatusInTitle enabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithTitleEnabled = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: true,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state as Idle with no thought
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'idle',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: null,
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithTitleEnabled,
-            });
-            // Assert: Check that title was updated with default Idle text
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            expect(titleWrites[0][0]).toBe(`\x1b]0;${'◇  Ready (workspace)'.padEnd(80, ' ')}\x07`);
-            unmount();
-        });
-        it('should update terminal title when in WaitingForConfirmation state with thought subject', async () => {
-            // Arrange: Set up mock settings with showStatusInTitle enabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithTitleEnabled = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: true,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state and thought
-            const thoughtSubject = 'Confirm tool execution';
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'waiting_for_confirmation',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: { subject: thoughtSubject },
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer({
-                    settings: mockSettingsWithTitleEnabled,
-                });
-                unmount = result.unmount;
-            });
-            // Assert: Check that title was updated with confirmation text
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            expect(titleWrites[0][0]).toBe(`\x1b]0;${'✋  Action Required (workspace)'.padEnd(80, ' ')}\x07`);
-            unmount();
-        });
-        describe('Shell Focus Action Required', () => {
-            beforeEach(() => {
-                vi.useFakeTimers();
-            });
-            afterEach(() => {
-                vi.useRealTimers();
-            });
-            it('should show Action Required in title after a delay when shell is awaiting focus', async () => {
-                const startTime = 1000000;
-                vi.setSystemTime(startTime);
-                // Arrange: Set up mock settings with showStatusInTitle enabled
-                const mockSettingsWithTitleEnabled = {
-                    ...mockSettings,
-                    merged: {
-                        ...mockSettings.merged,
-                        ui: {
-                            ...mockSettings.merged.ui,
-                            showStatusInTitle: true,
-                            hideWindowTitle: false,
-                        },
-                    },
-                };
-                // Mock an active shell pty but not focused
-                mockedUseGeminiStream.mockReturnValue({
-                    streamingState: 'responding',
-                    submitQuery: vi.fn(),
-                    initError: null,
-                    pendingHistoryItems: [],
-                    thought: { subject: 'Executing shell command' },
-                    cancelOngoingRequest: vi.fn(),
-                    pendingToolCalls: [],
-                    handleApprovalModeChange: vi.fn(),
-                    activePtyId: 'pty-1',
-                    loopDetectionConfirmationRequest: null,
-                    lastOutputTime: startTime + 100, // Trigger aggressive delay
-                    retryStatus: null,
-                });
-                vi.spyOn(mockConfig, 'isInteractive').mockReturnValue(true);
-                vi.spyOn(mockConfig, 'isInteractiveShellEnabled').mockReturnValue(true);
-                // Act: Render the container (embeddedShellFocused is false by default in state)
-                const { unmount } = renderAppContainer({
-                    settings: mockSettingsWithTitleEnabled,
-                });
-                // Initially it should show the working status
-                const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                expect(titleWrites[titleWrites.length - 1][0]).toContain('✦  Executing shell command');
-                // Fast-forward time by 40 seconds
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(40000);
-                });
-                // Now it should show Action Required
-                const titleWritesDelayed = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                const lastTitle = titleWritesDelayed[titleWritesDelayed.length - 1][0];
-                expect(lastTitle).toContain('✋  Action Required');
-                unmount();
-            });
-            it('should show Working… in title for redirected commands after 2 mins', async () => {
-                const startTime = 1000000;
-                vi.setSystemTime(startTime);
-                // Arrange: Set up mock settings with showStatusInTitle enabled
-                const mockSettingsWithTitleEnabled = {
-                    ...mockSettings,
-                    merged: {
-                        ...mockSettings.merged,
-                        ui: {
-                            ...mockSettings.merged.ui,
-                            showStatusInTitle: true,
-                            hideWindowTitle: false,
-                        },
-                    },
-                };
-                // Mock an active shell pty with redirection active
-                mockedUseGeminiStream.mockReturnValue({
-                    streamingState: 'responding',
-                    submitQuery: vi.fn(),
-                    initError: null,
-                    pendingHistoryItems: [],
-                    thought: { subject: 'Executing shell command' },
-                    cancelOngoingRequest: vi.fn(),
-                    pendingToolCalls: [
-                        {
-                            request: {
-                                name: 'run_shell_command',
-                                args: { command: 'ls > out' },
-                            },
-                            status: 'executing',
-                        },
-                    ],
-                    handleApprovalModeChange: vi.fn(),
-                    activePtyId: 'pty-1',
-                    loopDetectionConfirmationRequest: null,
-                    lastOutputTime: startTime,
-                    retryStatus: null,
-                });
-                vi.spyOn(mockConfig, 'isInteractive').mockReturnValue(true);
-                vi.spyOn(mockConfig, 'isInteractiveShellEnabled').mockReturnValue(true);
-                const { unmount } = renderAppContainer({
-                    settings: mockSettingsWithTitleEnabled,
-                });
-                // Fast-forward time by 65 seconds - should still NOT be Action Required
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(65000);
-                });
-                const titleWritesMid = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                expect(titleWritesMid[titleWritesMid.length - 1][0]).not.toContain('✋  Action Required');
-                // Fast-forward to 2 minutes (120000ms)
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(60000);
-                });
-                const titleWritesEnd = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                expect(titleWritesEnd[titleWritesEnd.length - 1][0]).toContain('⏲  Working…');
-                unmount();
-            });
-            it('should show Working… in title for silent non-redirected commands after 1 min', async () => {
-                const startTime = 1000000;
-                vi.setSystemTime(startTime);
-                // Arrange: Set up mock settings with showStatusInTitle enabled
-                const mockSettingsWithTitleEnabled = {
-                    ...mockSettings,
-                    merged: {
-                        ...mockSettings.merged,
-                        ui: {
-                            ...mockSettings.merged.ui,
-                            showStatusInTitle: true,
-                            hideWindowTitle: false,
-                        },
-                    },
-                };
-                // Mock an active shell pty with NO output since operation started (silent)
-                mockedUseGeminiStream.mockReturnValue({
-                    streamingState: 'responding',
-                    submitQuery: vi.fn(),
-                    initError: null,
-                    pendingHistoryItems: [],
-                    thought: { subject: 'Executing shell command' },
-                    cancelOngoingRequest: vi.fn(),
-                    pendingToolCalls: [],
-                    handleApprovalModeChange: vi.fn(),
-                    activePtyId: 'pty-1',
-                    loopDetectionConfirmationRequest: null,
-                    lastOutputTime: startTime, // lastOutputTime <= operationStartTime
-                    retryStatus: null,
-                });
-                vi.spyOn(mockConfig, 'isInteractive').mockReturnValue(true);
-                vi.spyOn(mockConfig, 'isInteractiveShellEnabled').mockReturnValue(true);
-                const { unmount } = renderAppContainer({
-                    settings: mockSettingsWithTitleEnabled,
-                });
-                // Fast-forward time by 65 seconds
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(65000);
-                });
-                const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                const lastTitle = titleWrites[titleWrites.length - 1][0];
-                // Should show Working… (⏲) instead of Action Required (✋)
-                expect(lastTitle).toContain('⏲  Working…');
-                unmount();
-            });
-            it('should NOT show Action Required in title if shell is streaming output', async () => {
-                const startTime = 1000000;
-                vi.setSystemTime(startTime);
-                // Arrange: Set up mock settings with showStatusInTitle enabled
-                const mockSettingsWithTitleEnabled = {
-                    ...mockSettings,
-                    merged: {
-                        ...mockSettings.merged,
-                        ui: {
-                            ...mockSettings.merged.ui,
-                            showStatusInTitle: true,
-                            hideWindowTitle: false,
-                        },
-                    },
-                };
-                // Mock an active shell pty but not focused
-                let lastOutputTime = startTime + 1000;
-                mockedUseGeminiStream.mockImplementation(() => ({
-                    streamingState: 'responding',
-                    submitQuery: vi.fn(),
-                    initError: null,
-                    pendingHistoryItems: [],
-                    thought: { subject: 'Executing shell command' },
-                    cancelOngoingRequest: vi.fn(),
-                    activePtyId: 'pty-1',
-                    lastOutputTime,
-                }));
-                vi.spyOn(mockConfig, 'isInteractive').mockReturnValue(true);
-                vi.spyOn(mockConfig, 'isInteractiveShellEnabled').mockReturnValue(true);
-                // Act: Render the container
-                const { unmount, rerender } = renderAppContainer({
-                    settings: mockSettingsWithTitleEnabled,
-                });
-                // Fast-forward time by 20 seconds
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(20000);
-                });
-                // Update lastOutputTime to simulate new output
-                lastOutputTime = startTime + 21000;
-                mockedUseGeminiStream.mockImplementation(() => ({
-                    streamingState: 'responding',
-                    submitQuery: vi.fn(),
-                    initError: null,
-                    pendingHistoryItems: [],
-                    thought: { subject: 'Executing shell command' },
-                    cancelOngoingRequest: vi.fn(),
-                    activePtyId: 'pty-1',
-                    lastOutputTime,
-                }));
-                // Rerender to propagate the new lastOutputTime
-                await act(async () => {
-                    rerender(getAppContainer({ settings: mockSettingsWithTitleEnabled }));
-                });
-                // Fast-forward time by another 20 seconds
-                // Total time elapsed: 40s.
-                // Time since last output: 20s.
-                // It should NOT show Action Required yet.
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(20000);
-                });
-                const titleWritesAfterOutput = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                const lastTitle = titleWritesAfterOutput[titleWritesAfterOutput.length - 1][0];
-                expect(lastTitle).not.toContain('✋  Action Required');
-                expect(lastTitle).toContain('✦  Executing shell command');
-                // Fast-forward another 40 seconds (Total 60s since last output)
-                await act(async () => {
-                    await vi.advanceTimersByTimeAsync(40000);
-                });
-                // Now it SHOULD show Action Required
-                const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-                const lastTitleFinal = titleWrites[titleWrites.length - 1][0];
-                expect(lastTitleFinal).toContain('✋  Action Required');
-                unmount();
-            });
-        });
-        it('should pad title to exactly 80 characters', () => {
-            // Arrange: Set up mock settings with showStatusInTitle enabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithTitleEnabled = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: true,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state and thought with a short subject
-            const shortTitle = 'Short';
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: { subject: shortTitle },
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithTitleEnabled,
-            });
-            // Assert: Check that title is padded to exactly 80 characters
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            const calledWith = titleWrites[0][0];
-            const expectedTitle = `✦  ${shortTitle} (workspace)`.padEnd(80, ' ');
-            const expectedEscapeSequence = `\x1b]0;${expectedTitle}\x07`;
-            expect(calledWith).toBe(expectedEscapeSequence);
-            unmount();
-        });
-        it('should use correct ANSI escape code format', () => {
-            // Arrange: Set up mock settings with showStatusInTitle enabled
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const mockSettingsWithTitleEnabled = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        showStatusInTitle: true,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock the streaming state and thought
-            const title = 'Test Title';
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: { subject: title },
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithTitleEnabled,
-            });
-            // Assert: Check that the correct ANSI escape sequence is used
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            const expectedEscapeSequence = `\x1b]0;${`✦  ${title} (workspace)`.padEnd(80, ' ')}\x07`;
-            expect(titleWrites[0][0]).toBe(expectedEscapeSequence);
-            unmount();
-        });
-        it('should use CLI_TITLE environment variable when set', () => {
-            // Arrange: Set up mock settings with showStatusInTitle disabled (so it shows suffix)
-            const mockSettingsWithTitleDisabled = {
-                ...mockSettings,
-                merged: {
-                    ...mockSettings.merged,
-                    ui: {
-                        ...mockSettings.merged.ui,
-                        showStatusInTitle: false,
-                        hideWindowTitle: false,
-                    },
-                },
-            };
-            // Mock CLI_TITLE environment variable
-            vi.stubEnv('CLI_TITLE', 'Custom Gemini Title');
-            // Mock the streaming state
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: null,
-                cancelOngoingRequest: vi.fn(),
-            });
-            // Act: Render the container
-            const { unmount } = renderAppContainer({
-                settings: mockSettingsWithTitleDisabled,
-            });
-            // Assert: Check that title was updated with CLI_TITLE value
-            const titleWrites = mocks.mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]0;'));
-            expect(titleWrites).toHaveLength(1);
-            expect(titleWrites[0][0]).toBe(`\x1b]0;${'✦  Working… (Custom Gemini Title)'.padEnd(80, ' ')}\x07`);
-            unmount();
-        });
-    });
-    describe('Queue Error Message', () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-            vi.restoreAllMocks();
-        });
-        it('should set and clear the queue error message after a timeout', async () => {
-            const { rerender, unmount } = renderAppContainer();
-            await act(async () => {
-                vi.advanceTimersByTime(0);
-            });
-            expect(capturedUIState.queueErrorMessage).toBeNull();
-            act(() => {
-                capturedUIActions.setQueueErrorMessage('Test error');
-            });
-            rerender(getAppContainer());
-            expect(capturedUIState.queueErrorMessage).toBe('Test error');
-            act(() => {
-                vi.advanceTimersByTime(3000);
-            });
-            rerender(getAppContainer());
-            expect(capturedUIState.queueErrorMessage).toBeNull();
-            unmount();
-        });
-        it('should reset the timer if a new error message is set', async () => {
-            const { rerender, unmount } = renderAppContainer();
-            await act(async () => {
-                vi.advanceTimersByTime(0);
-            });
-            act(() => {
-                capturedUIActions.setQueueErrorMessage('First error');
-            });
-            rerender(getAppContainer());
-            expect(capturedUIState.queueErrorMessage).toBe('First error');
-            act(() => {
-                vi.advanceTimersByTime(1500);
-            });
-            act(() => {
-                capturedUIActions.setQueueErrorMessage('Second error');
-            });
-            rerender(getAppContainer());
-            expect(capturedUIState.queueErrorMessage).toBe('Second error');
-            act(() => {
-                vi.advanceTimersByTime(2000);
-            });
-            rerender(getAppContainer());
-            expect(capturedUIState.queueErrorMessage).toBe('Second error');
-            // 5. Advance time past the 3 second timeout from the second message
-            act(() => {
-                vi.advanceTimersByTime(1000);
-            });
-            rerender(getAppContainer());
-            expect(capturedUIState.queueErrorMessage).toBeNull();
-            unmount();
-        });
-    });
-    describe('Terminal Height Calculation', () => {
-        const mockedMeasureElement = measureElement;
-        const mockedUseTerminalSize = useTerminalSize;
-        it('should prevent terminal height from being less than 1', async () => {
-            const resizePtySpy = vi.spyOn(ShellExecutionService, 'resizePty');
-            // Arrange: Simulate a small terminal and a large footer
-            mockedUseTerminalSize.mockReturnValue({ columns: 80, rows: 5 });
-            mockedMeasureElement.mockReturnValue({ width: 80, height: 10 }); // Footer is taller than the screen
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'idle',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: null,
-                cancelOngoingRequest: vi.fn(),
-                activePtyId: 'some-id',
-            });
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(resizePtySpy).toHaveBeenCalled());
-            const lastCall = resizePtySpy.mock.calls[resizePtySpy.mock.calls.length - 1];
-            // Check the height argument specifically
-            expect(lastCall[2]).toBe(1);
-            unmount();
-        });
-    });
-    describe('Keyboard Input Handling (CTRL+C / CTRL+D)', () => {
-        let handleGlobalKeypress;
-        let mockHandleSlashCommand;
-        let mockCancelOngoingRequest;
-        let rerender;
-        let unmount;
-        // Helper function to reduce boilerplate in tests
-        const setupKeypressTest = async () => {
-            const renderResult = renderAppContainer();
-            await act(async () => {
-                vi.advanceTimersByTime(0);
-            });
-            rerender = () => renderResult.rerender(getAppContainer());
-            unmount = renderResult.unmount;
-        };
-        const pressKey = (key, times = 1) => {
-            for (let i = 0; i < times; i++) {
-                act(() => {
-                    handleGlobalKeypress({
-                        name: 'c',
-                        shift: false,
-                        alt: false,
-                        ctrl: false,
-                        cmd: false,
-                        ...key,
-                    });
-                });
-                rerender();
-            }
-        };
-        beforeEach(() => {
-            // Capture the keypress handler from the AppContainer
-            mockedUseKeypress.mockImplementation((callback) => {
-                handleGlobalKeypress = callback;
-            });
-            // Mock slash command handler
-            mockHandleSlashCommand = vi.fn();
-            mockedUseSlashCommandProcessor.mockReturnValue({
-                handleSlashCommand: mockHandleSlashCommand,
-                slashCommands: [],
-                pendingHistoryItems: [],
-                commandContext: {},
-                shellConfirmationRequest: null,
-                confirmationRequest: null,
-            });
-            // Mock request cancellation
-            mockCancelOngoingRequest = vi.fn();
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'idle',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: null,
-                cancelOngoingRequest: mockCancelOngoingRequest,
-            });
-            // Default empty text buffer
-            mockedUseTextBuffer.mockReturnValue({
-                text: '',
-                setText: vi.fn(),
-            });
-            vi.useFakeTimers();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-            vi.restoreAllMocks();
-        });
-        describe('CTRL+C', () => {
-            it('should cancel ongoing request on first press', async () => {
-                mockedUseGeminiStream.mockReturnValue({
-                    streamingState: 'responding',
-                    submitQuery: vi.fn(),
-                    initError: null,
-                    pendingHistoryItems: [],
-                    thought: null,
-                    cancelOngoingRequest: mockCancelOngoingRequest,
-                });
-                await setupKeypressTest();
-                pressKey({ name: 'c', ctrl: true });
-                expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(1);
-                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
-                unmount();
-            });
-            it('should quit on second press', async () => {
-                await setupKeypressTest();
-                pressKey({ name: 'c', ctrl: true }, 2);
-                expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(2);
-                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit', undefined, undefined, false);
-                unmount();
-            });
-            it('should reset press count after a timeout', async () => {
-                await setupKeypressTest();
-                pressKey({ name: 'c', ctrl: true });
-                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
-                // Advance timer past the reset threshold
-                act(() => {
-                    vi.advanceTimersByTime(1001);
-                });
-                pressKey({ name: 'c', ctrl: true });
-                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
-                unmount();
-            });
-        });
-        describe('CTRL+D', () => {
-            it('should do nothing if text buffer is not empty', async () => {
-                mockedUseTextBuffer.mockReturnValue({
-                    text: 'some text',
-                    setText: vi.fn(),
-                });
-                await setupKeypressTest();
-                pressKey({ name: 'd', ctrl: true }, 2);
-                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
-                unmount();
-            });
-            it('should quit on second press if buffer is empty', async () => {
-                await setupKeypressTest();
-                pressKey({ name: 'd', ctrl: true }, 2);
-                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit', undefined, undefined, false);
-                unmount();
-            });
-            it('should reset press count after a timeout', async () => {
-                await setupKeypressTest();
-                pressKey({ name: 'd', ctrl: true });
-                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
-                // Advance timer past the reset threshold
-                act(() => {
-                    vi.advanceTimersByTime(1001);
-                });
-                pressKey({ name: 'd', ctrl: true });
-                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
-                unmount();
-            });
-        });
-    });
-    describe('Copy Mode (CTRL+S)', () => {
-        let handleGlobalKeypress;
-        let rerender;
-        let unmount;
-        const setupCopyModeTest = async (isAlternateMode = false) => {
-            // Update settings for this test run
-            const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
-            const testSettings = {
-                ...mockSettings,
-                merged: {
-                    ...defaultMergedSettings,
-                    ui: {
-                        ...defaultMergedSettings.ui,
-                        useAlternateBuffer: isAlternateMode,
-                    },
-                },
-            };
-            const renderResult = renderAppContainer({ settings: testSettings });
-            await act(async () => {
-                vi.advanceTimersByTime(0);
-            });
-            rerender = () => renderResult.rerender(getAppContainer({ settings: testSettings }));
-            unmount = renderResult.unmount;
-        };
-        beforeEach(() => {
-            mocks.mockStdout.write.mockClear();
-            mockedUseKeypress.mockImplementation((callback) => {
-                handleGlobalKeypress = callback;
-            });
-            vi.useFakeTimers();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-            vi.restoreAllMocks();
-        });
-        describe.each([
-            {
-                isAlternateMode: false,
-                shouldEnable: false,
-                modeName: 'Normal Mode',
-            },
-            {
-                isAlternateMode: true,
-                shouldEnable: true,
-                modeName: 'Alternate Buffer Mode',
-            },
-        ])('$modeName', ({ isAlternateMode, shouldEnable }) => {
-            it(`should ${shouldEnable ? 'toggle' : 'NOT toggle'} mouse off when Ctrl+S is pressed`, async () => {
-                await setupCopyModeTest(isAlternateMode);
-                mocks.mockStdout.write.mockClear(); // Clear initial enable call
-                act(() => {
-                    handleGlobalKeypress({
-                        name: 's',
-                        shift: false,
-                        alt: false,
-                        ctrl: true,
-                        cmd: false,
-                        insertable: false,
-                        sequence: '\x13',
-                    });
-                });
-                rerender();
-                if (shouldEnable) {
-                    expect(disableMouseEvents).toHaveBeenCalled();
-                }
-                else {
-                    expect(disableMouseEvents).not.toHaveBeenCalled();
-                }
-                unmount();
-            });
-            if (shouldEnable) {
-                it('should toggle mouse back on when Ctrl+S is pressed again', async () => {
-                    await setupCopyModeTest(isAlternateMode);
-                    writeToStdout.mockClear();
-                    // Turn it on (disable mouse)
-                    act(() => {
-                        handleGlobalKeypress({
-                            name: 's',
-                            shift: false,
-                            alt: false,
-                            ctrl: true,
-                            cmd: false,
-                            insertable: false,
-                            sequence: '\x13',
-                        });
-                    });
-                    rerender();
-                    expect(disableMouseEvents).toHaveBeenCalled();
-                    // Turn it off (enable mouse)
-                    act(() => {
-                        handleGlobalKeypress({
-                            name: 'any', // Any key should exit copy mode
-                            shift: false,
-                            alt: false,
-                            ctrl: false,
-                            cmd: false,
-                            insertable: true,
-                            sequence: 'a',
-                        });
-                    });
-                    rerender();
-                    expect(enableMouseEvents).toHaveBeenCalled();
-                    unmount();
-                });
-                it('should exit copy mode on any key press', async () => {
-                    await setupCopyModeTest(isAlternateMode);
-                    // Enter copy mode
-                    act(() => {
-                        handleGlobalKeypress({
-                            name: 's',
-                            shift: false,
-                            alt: false,
-                            ctrl: true,
-                            cmd: false,
-                            insertable: false,
-                            sequence: '\x13',
-                        });
-                    });
-                    rerender();
-                    writeToStdout.mockClear();
-                    // Press any other key
-                    act(() => {
-                        handleGlobalKeypress({
-                            name: 'a',
-                            shift: false,
-                            alt: false,
-                            ctrl: false,
-                            cmd: false,
-                            insertable: true,
-                            sequence: 'a',
-                        });
-                    });
-                    rerender();
-                    // Should have re-enabled mouse
-                    expect(enableMouseEvents).toHaveBeenCalled();
-                    unmount();
-                });
-            }
-        });
-    });
-    describe('Model Dialog Integration', () => {
-        it('should provide isModelDialogOpen in the UIStateContext', async () => {
-            mockedUseModelCommand.mockReturnValue({
-                isModelDialogOpen: true,
-                openModelDialog: vi.fn(),
-                closeModelDialog: vi.fn(),
-            });
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            expect(capturedUIState.isModelDialogOpen).toBe(true);
-            unmount();
-        });
-        it('should provide model dialog actions in the UIActionsContext', async () => {
-            const mockCloseModelDialog = vi.fn();
-            mockedUseModelCommand.mockReturnValue({
-                isModelDialogOpen: false,
-                openModelDialog: vi.fn(),
-                closeModelDialog: mockCloseModelDialog,
-            });
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            // Verify that the actions are correctly passed through context
-            act(() => {
-                capturedUIActions.closeModelDialog();
-            });
-            expect(mockCloseModelDialog).toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('Agent Configuration Dialog Integration', () => {
-        it('should initialize with dialog closed and no agent selected', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            expect(capturedUIState.isAgentConfigDialogOpen).toBe(false);
-            expect(capturedUIState.selectedAgentName).toBeUndefined();
-            expect(capturedUIState.selectedAgentDisplayName).toBeUndefined();
-            expect(capturedUIState.selectedAgentDefinition).toBeUndefined();
-            unmount();
-        });
-        it('should update state when openAgentConfigDialog is called', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            const agentDefinition = { name: 'test-agent' };
-            act(() => {
-                capturedUIActions.openAgentConfigDialog('test-agent', 'Test Agent', agentDefinition);
-            });
-            expect(capturedUIState.isAgentConfigDialogOpen).toBe(true);
-            expect(capturedUIState.selectedAgentName).toBe('test-agent');
-            expect(capturedUIState.selectedAgentDisplayName).toBe('Test Agent');
-            expect(capturedUIState.selectedAgentDefinition).toEqual(agentDefinition);
-            unmount();
-        });
-        it('should clear state when closeAgentConfigDialog is called', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            const agentDefinition = { name: 'test-agent' };
-            act(() => {
-                capturedUIActions.openAgentConfigDialog('test-agent', 'Test Agent', agentDefinition);
-            });
-            expect(capturedUIState.isAgentConfigDialogOpen).toBe(true);
-            act(() => {
-                capturedUIActions.closeAgentConfigDialog();
-            });
-            expect(capturedUIState.isAgentConfigDialogOpen).toBe(false);
-            expect(capturedUIState.selectedAgentName).toBeUndefined();
-            expect(capturedUIState.selectedAgentDisplayName).toBeUndefined();
-            expect(capturedUIState.selectedAgentDefinition).toBeUndefined();
-            unmount();
-        });
-    });
-    describe('CoreEvents Integration', () => {
-        it('subscribes to UserFeedback and drains backlog on mount', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            expect(mockCoreEvents.on).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
-            expect(mockCoreEvents.drainBacklogs).toHaveBeenCalledTimes(1);
-            unmount();
-        });
-        it('unsubscribes from UserFeedback on unmount', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            unmount();
-            expect(mockCoreEvents.off).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
-        });
-        it('adds history item when UserFeedback event is received', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            // Get the registered handler
-            const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.UserFeedback)?.[1];
-            expect(handler).toBeDefined();
-            // Simulate an event
-            const payload = {
-                severity: 'error',
-                message: 'Test error message',
-            };
-            act(() => {
-                handler(payload);
-            });
-            expect(mockedUseHistory().addItem).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'error',
-                text: 'Test error message',
-            }), expect.any(Number));
-            unmount();
-        });
-        it('updates currentModel when ModelChanged event is received', async () => {
-            // Arrange: Mock initial model
-            vi.spyOn(mockConfig, 'getModel').mockReturnValue('initial-model');
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => {
-                expect(capturedUIState?.currentModel).toBe('initial-model');
-            });
-            // Get the registered handler for ModelChanged
-            const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.ModelChanged)?.[1];
-            expect(handler).toBeDefined();
-            // Act: Simulate ModelChanged event
-            // Update config mock to return new model since the handler reads from config
-            vi.spyOn(mockConfig, 'getModel').mockReturnValue('new-model');
-            act(() => {
-                handler({ model: 'new-model' });
-            });
-            // Assert: Verify model is updated
-            await waitFor(() => {
-                expect(capturedUIState.currentModel).toBe('new-model');
-            });
-            unmount();
-        });
-        it('provides activeHooks from useHookDisplayState', async () => {
-            const mockHooks = [{ name: 'hook1', eventName: 'event1' }];
-            mockedUseHookDisplayState.mockReturnValue(mockHooks);
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            expect(capturedUIState.activeHooks).toEqual(mockHooks);
-            unmount();
-        });
-    });
-    describe('Shell Interaction', () => {
-        it('should not crash if resizing the pty fails', async () => {
-            const resizePtySpy = vi
-                .spyOn(ShellExecutionService, 'resizePty')
-                .mockImplementation(() => {
-                throw new Error('Cannot resize a pty that has already exited');
-            });
-            mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'idle',
-                submitQuery: vi.fn(),
-                initError: null,
-                pendingHistoryItems: [],
-                thought: null,
-                cancelOngoingRequest: vi.fn(),
-                activePtyId: 'some-pty-id', // Make sure activePtyId is set
-            });
-            // The main assertion is that the render does not throw.
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(resizePtySpy).toHaveBeenCalled());
-            unmount();
-        });
-    });
-    describe('Banner Text', () => {
-        it('should render placeholder banner text for USE_GEMINI auth type', async () => {
-            const config = makeFakeConfig();
-            vi.spyOn(config, 'getContentGeneratorConfig').mockReturnValue({
-                authType: AuthType.USE_GEMINI,
-                apiKey: 'fake-key',
-            });
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => {
-                expect(capturedUIState.bannerData.defaultText).toBeDefined();
-                unmount();
-            });
-        });
-    });
-    describe('onCancelSubmit Behavior', () => {
-        let mockSetText;
-        // Helper to extract arguments from the useGeminiStream hook call
-        // This isolates the positional argument dependency to a single location
-        const extractUseGeminiStreamArgs = (args) => ({
-            onCancelSubmit: args[13],
-        });
-        beforeEach(() => {
-            mockSetText = vi.fn();
-            mockedUseTextBuffer.mockReturnValue({
-                text: '',
-                setText: mockSetText,
-            });
-        });
-        it('clears the prompt when onCancelSubmit is called with shouldRestorePrompt=false', async () => {
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            const { onCancelSubmit } = extractUseGeminiStreamArgs(mockedUseGeminiStream.mock.lastCall);
-            act(() => {
-                onCancelSubmit(false);
-            });
-            expect(mockSetText).toHaveBeenCalledWith('');
-            unmount();
-        });
-        it('restores the prompt when onCancelSubmit is called with shouldRestorePrompt=true (or undefined)', async () => {
-            // Mock useInputHistoryStore to provide input history
-            mockedUseInputHistoryStore.mockReturnValue({
-                inputHistory: ['previous message'],
-                addInput: vi.fn(),
-                initializeFromLogger: vi.fn(),
-            });
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                unmount = result.unmount;
-            });
-            await waitFor(() => expect(capturedUIState.userMessages).toContain('previous message'));
-            const { onCancelSubmit } = extractUseGeminiStreamArgs(mockedUseGeminiStream.mock.lastCall);
-            await act(async () => {
-                onCancelSubmit(true);
-            });
-            await waitFor(() => {
-                expect(mockSetText).toHaveBeenCalledWith('previous message');
-            });
-            unmount();
-        });
-        it('input history is independent from conversation history (survives /clear)', async () => {
-            // This test verifies that input history (used for up-arrow navigation) is maintained
-            // separately from conversation history and survives /clear operations.
-            const mockAddInput = vi.fn();
-            mockedUseInputHistoryStore.mockReturnValue({
-                inputHistory: ['first prompt', 'second prompt'],
-                addInput: mockAddInput,
-                initializeFromLogger: vi.fn(),
-            });
-            let rerender;
-            let unmount;
-            await act(async () => {
-                const result = renderAppContainer();
-                rerender = result.rerender;
-                unmount = result.unmount;
-            });
-            // Verify userMessages is populated from inputHistory
-            await waitFor(() => expect(capturedUIState.userMessages).toContain('first prompt'));
-            expect(capturedUIState.userMessages).toContain('second prompt');
-            // Clear the conversation history (simulating /clear command)
-            const mockClearItems = vi.fn();
-            mockedUseHistory.mockReturnValue({
-                history: [],
-                addItem: vi.fn(),
-                updateItem: vi.fn(),
-                clearItems: mockClearItems,
-                loadHistory: vi.fn(),
-            });
-            await act(async () => {
-                // Rerender to apply the new mock.
-                rerender(getAppContainer());
-            });
-            // Verify that userMessages still contains the input history
-            // (it should not be affected by clearing conversation history)
-            expect(capturedUIState.userMessages).toContain('first prompt');
-            expect(capturedUIState.userMessages).toContain('second prompt');
-            unmount();
-        });
-    });
-    describe('Regression Tests', () => {
-        it('does not refresh static on startup if banner text is empty', async () => {
-            // Mock banner text to be empty strings
-            vi.spyOn(mockConfig, 'getBannerTextNoCapacityIssues').mockResolvedValue('');
-            vi.spyOn(mockConfig, 'getBannerTextCapacityIssues').mockResolvedValue('');
-            // Clear previous calls
-            mocks.mockStdout.write.mockClear();
-            let compUnmount = () => { };
-            await act(async () => {
-                const { unmount } = renderAppContainer();
-                compUnmount = unmount;
-            });
-            // Allow async effects to run
-            await waitFor(() => expect(capturedUIState).toBeTruthy());
-            // Wait for fetchBannerTexts to complete
-            await act(async () => {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            });
-            // Check that clearTerminal was NOT written to stdout
-            const clearTerminalCalls = mocks.mockStdout.write.mock.calls.filter((call) => call[0] === ansiEscapes.clearTerminal);
-            expect(clearTerminalCalls).toHaveLength(0);
-            compUnmount();
-        });
-    });
-});
-//# sourceMappingURL=AppContainer.test.js.map