@google/gemini-cli 0.15.0-nightly.20251111.51f952e7 → 0.15.0-preview.0

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

@@ -9,6 +9,7 @@ import { render } from '../test-utils/render.js';
 import { cleanup } from 'ink-testing-library';
 import { act, useContext } from 'react';
 import { AppContainer } from './AppContainer.js';
+import { SettingsContext } from './contexts/SettingsContext.js';
 import { makeFakeConfig, CoreEvent, } from '@google/gemini-cli-core';
 // Mock coreEvents
 const mockCoreEvents = vi.hoisted(() => ({
@@ -116,6 +117,10 @@ describe('AppContainer State Management', () => {
     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;
@@ -270,6 +275,7 @@ describe('AppContainer State Management', () => {
                     showStatusInTitle: false,
                     hideWindowTitle: false,
                 },
+                useAlternateBuffer: false,
             },
         };
         // Mock InitializationResult
@@ -285,7 +291,7 @@ describe('AppContainer State Management', () => {
     });
     describe('Basic Rendering', () => {
         it('renders without crashing with minimal props', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -293,7 +299,7 @@ describe('AppContainer State Management', () => {
         });
         it('renders with startup warnings', async () => {
             const startupWarnings = ['Warning 1', 'Warning 2'];
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, startupWarnings: startupWarnings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ startupWarnings });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -306,7 +312,9 @@ describe('AppContainer State Management', () => {
                 ...mockInitResult,
                 themeError: 'Failed to load theme',
             };
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: initResultWithError }));
+            const { unmount } = renderAppContainer({
+                initResult: initResultWithError,
+            });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -316,13 +324,13 @@ describe('AppContainer State Management', () => {
             const debugConfig = makeFakeConfig();
             vi.spyOn(debugConfig, 'getDebugMode').mockReturnValue(true);
             expect(() => {
-                render(_jsx(AppContainer, { config: debugConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+                renderAppContainer({ config: debugConfig });
             }).not.toThrow();
         });
     });
     describe('Context Providers', () => {
         it('provides AppContext with correct values', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "2.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ version: '2.0.0' });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -330,21 +338,21 @@ describe('AppContainer State Management', () => {
             expect(() => unmount()).not.toThrow();
         });
         it('provides UIStateContext with state management', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
             unmount();
         });
         it('provides UIActionsContext with action handlers', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
             unmount();
         });
         it('provides ConfigContext with config object', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -361,7 +369,7 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: false,
                 },
             };
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: settingsAllHidden, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ settings: settingsAllHidden });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -376,7 +384,7 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: true,
                 },
             };
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: settingsWithMemory, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ settings: settingsWithMemory });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -385,7 +393,7 @@ describe('AppContainer State Management', () => {
     });
     describe('Version Handling', () => {
         it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', async (version) => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: version, initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ version });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -399,7 +407,7 @@ describe('AppContainer State Management', () => {
                 throw new Error('Config error');
             });
             // Should still render without crashing - errors should be handled internally
-            const { unmount } = render(_jsx(AppContainer, { config: errorConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ config: errorConfig });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -409,7 +417,7 @@ describe('AppContainer State Management', () => {
             const undefinedSettings = {
                 merged: {},
             };
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: undefinedSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({ settings: undefinedSettings });
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -420,14 +428,294 @@ describe('AppContainer State Management', () => {
         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 } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            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
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -447,7 +735,7 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -463,7 +751,7 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: mockHandler,
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -496,7 +784,9 @@ describe('AppContainer State Management', () => {
                 },
             };
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithShowStatusFalse, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithShowStatusFalse,
+            });
             // Assert: Check that no title-related writes occurred
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(0);
@@ -516,7 +806,9 @@ describe('AppContainer State Management', () => {
                 },
             };
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithHideTitleTrue, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithHideTitleTrue,
+            });
             // Assert: Check that no title-related writes occurred
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(0);
@@ -546,7 +838,9 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithTitleEnabled, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithTitleEnabled,
+            });
             // Assert: Check that title was updated with thought subject
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(1);
@@ -576,7 +870,9 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithTitleEnabled, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithTitleEnabled,
+            });
             // Assert: Check that title was updated with default Idle text
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(1);
@@ -607,7 +903,9 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithTitleEnabled, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithTitleEnabled,
+            });
             // Assert: Check that title was updated with confirmation text
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(1);
@@ -638,7 +936,9 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithTitleEnabled, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithTitleEnabled,
+            });
             // Assert: Check that title is padded to exactly 80 characters
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(1);
@@ -674,7 +974,9 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithTitleEnabled, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithTitleEnabled,
+            });
             // Assert: Check that the correct ANSI escape sequence is used
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(1);
@@ -707,7 +1009,9 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettingsWithTitleEnabled, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer({
+                settings: mockSettingsWithTitleEnabled,
+            });
             // Assert: Check that title was updated with CLI_TITLE value
             const titleWrites = mockStdout.write.mock.calls.filter((call) => call[0].includes('\x1b]2;'));
             expect(titleWrites).toHaveLength(1);
@@ -723,7 +1027,7 @@ describe('AppContainer State Management', () => {
             vi.useRealTimers();
         });
         it('should set and clear the queue error message after a timeout', async () => {
-            const { rerender, unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { rerender, unmount } = renderAppContainer();
             await act(async () => {
                 vi.advanceTimersByTime(0);
             });
@@ -731,24 +1035,24 @@ describe('AppContainer State Management', () => {
             act(() => {
                 capturedUIActions.setQueueErrorMessage('Test error');
             });
-            rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender(getAppContainer());
             expect(capturedUIState.queueErrorMessage).toBe('Test error');
             act(() => {
                 vi.advanceTimersByTime(3000);
             });
-            rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender(getAppContainer());
             expect(capturedUIState.queueErrorMessage).toBeNull();
             unmount();
         });
         it('should reset the timer if a new error message is set', async () => {
-            const { rerender, unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { rerender, unmount } = renderAppContainer();
             await act(async () => {
                 vi.advanceTimersByTime(0);
             });
             act(() => {
                 capturedUIActions.setQueueErrorMessage('First error');
             });
-            rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender(getAppContainer());
             expect(capturedUIState.queueErrorMessage).toBe('First error');
             act(() => {
                 vi.advanceTimersByTime(1500);
@@ -756,18 +1060,18 @@ describe('AppContainer State Management', () => {
             act(() => {
                 capturedUIActions.setQueueErrorMessage('Second error');
             });
-            rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender(getAppContainer());
             expect(capturedUIState.queueErrorMessage).toBe('Second error');
             act(() => {
                 vi.advanceTimersByTime(2000);
             });
-            rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            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(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender(getAppContainer());
             expect(capturedUIState.queueErrorMessage).toBeNull();
             unmount();
         });
@@ -789,7 +1093,7 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
                 activePtyId: 'some-id',
             });
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -810,11 +1114,11 @@ describe('AppContainer State Management', () => {
         let unmount;
         // Helper function to reduce boilerplate in tests
         const setupKeypressTest = async () => {
-            const renderResult = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const renderResult = renderAppContainer();
             await act(async () => {
                 vi.advanceTimersByTime(0);
             });
-            rerender = () => renderResult.rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender = () => renderResult.rerender(getAppContainer());
             unmount = renderResult.unmount;
         };
         const pressKey = (key, times = 1) => {
@@ -949,11 +1253,11 @@ describe('AppContainer State Management', () => {
                     },
                 },
             };
-            const renderResult = render(_jsx(AppContainer, { config: mockConfig, settings: testSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const renderResult = renderAppContainer({ settings: testSettings });
             await act(async () => {
                 vi.advanceTimersByTime(0);
             });
-            rerender = () => renderResult.rerender(_jsx(AppContainer, { config: mockConfig, settings: testSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            rerender = () => renderResult.rerender(getAppContainer({ settings: testSettings }));
             unmount = renderResult.unmount;
         };
         beforeEach(() => {
@@ -1078,7 +1382,7 @@ describe('AppContainer State Management', () => {
                 openModelDialog: vi.fn(),
                 closeModelDialog: vi.fn(),
             });
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -1092,7 +1396,7 @@ describe('AppContainer State Management', () => {
                 openModelDialog: vi.fn(),
                 closeModelDialog: mockCloseModelDialog,
             });
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -1106,7 +1410,7 @@ describe('AppContainer State Management', () => {
     });
     describe('CoreEvents Integration', () => {
         it('subscribes to UserFeedback and drains backlog on mount', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -1115,7 +1419,7 @@ describe('AppContainer State Management', () => {
             unmount();
         });
         it('unsubscribes from UserFeedback on unmount', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -1123,7 +1427,7 @@ describe('AppContainer State Management', () => {
             expect(mockCoreEvents.off).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
         });
         it('adds history item when UserFeedback event is received', async () => {
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });
@@ -1147,8 +1451,7 @@ describe('AppContainer State Management', () => {
         it('updates currentModel when ModelChanged event is received', async () => {
             // Arrange: Mock initial model
             vi.spyOn(mockConfig, 'getModel').mockReturnValue('initial-model');
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            // Verify initial model
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await vi.waitFor(() => {
                     expect(capturedUIState?.currentModel).toBe('initial-model');
@@ -1183,7 +1486,7 @@ describe('AppContainer State Management', () => {
                 activePtyId: 'some-pty-id', // Make sure activePtyId is set
             });
             // The main assertion is that the render does not throw.
-            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = renderAppContainer();
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             });