@google/gemini-cli 0.30.1 → 0.31.0-preview.1

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

@@ -5,14 +5,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { render, persistentStateMock } from '../test-utils/render.js';
+import { render, cleanup, persistentStateMock } 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/useToolScheduler.js';
-import { makeFakeConfig, CoreEvent, AuthType, CoreToolCallStatus, } from '@google/gemini-cli-core';
+import { makeFakeConfig, CoreEvent, WarningPriority, AuthType, CoreToolCallStatus, } from '@google/gemini-cli-core';
 // Mock coreEvents
 const mockCoreEvents = vi.hoisted(() => ({
     on: vi.fn(),
@@ -28,6 +27,15 @@ const mockIdeClient = vi.hoisted(() => ({
 const mocks = vi.hoisted(() => ({
     mockStdout: { write: vi.fn() },
 }));
+const terminalNotificationsMocks = vi.hoisted(() => ({
+    notifyViaTerminal: vi.fn().mockResolvedValue(true),
+    isNotificationsEnabled: vi.fn(() => true),
+    buildRunEventNotificationContent: vi.fn((event) => ({
+        title: 'Mock Notification',
+        subtitle: 'Mock Subtitle',
+        body: JSON.stringify(event),
+    })),
+}));
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -60,6 +68,8 @@ import { StreamingState } from './types.js';
 import { UIStateContext } from './contexts/UIStateContext.js';
 import { UIActionsContext, } from './contexts/UIActionsContext.js';
 import { KeypressProvider } from './contexts/KeypressContext.js';
+import { OverflowProvider } from './contexts/OverflowContext.js';
+import { useOverflowActions, } from './contexts/OverflowContext.js';
 // Mock useStdout to capture terminal title writes
 vi.mock('ink', async (importOriginal) => {
     const actual = await importOriginal();
@@ -73,9 +83,11 @@ vi.mock('ink', async (importOriginal) => {
 // so we can assert against them in our tests.
 let capturedUIState;
 let capturedUIActions;
+let capturedOverflowActions;
 function TestContextConsumer() {
     capturedUIState = useContext(UIStateContext);
     capturedUIActions = useContext(UIActionsContext);
+    capturedOverflowActions = useOverflowActions();
     return null;
 }
 vi.mock('./App.js', () => ({
@@ -124,12 +136,18 @@ vi.mock('./hooks/useShellInactivityStatus.js', () => ({
         inactivityStatus: 'none',
     })),
 }));
+vi.mock('../utils/terminalNotifications.js', () => ({
+    notifyViaTerminal: terminalNotificationsMocks.notifyViaTerminal,
+    isNotificationsEnabled: terminalNotificationsMocks.isNotificationsEnabled,
+    buildRunEventNotificationContent: terminalNotificationsMocks.buildRunEventNotificationContent,
+}));
 vi.mock('./hooks/useTerminalTheme.js', () => ({
     useTerminalTheme: vi.fn(),
 }));
 import { useHookDisplayState } from './hooks/useHookDisplayState.js';
 import { useTerminalTheme } from './hooks/useTerminalTheme.js';
 import { useShellInactivityStatus } from './hooks/useShellInactivityStatus.js';
+import { useFocus } from './hooks/useFocus.js';
 // Mock external utilities
 vi.mock('../utils/events.js');
 vi.mock('../utils/handleAutoUpdate.js');
@@ -163,14 +181,14 @@ import { measureElement } from 'ink';
 import { useTerminalSize } from './hooks/useTerminalSize.js';
 import { ShellExecutionService, writeToStdout, enableMouseEvents, disableMouseEvents, } from '@google/gemini-cli-core';
 import {} from '../config/extension-manager.js';
-import { WARNING_PROMPT_DURATION_MS } from './constants.js';
+import { WARNING_PROMPT_DURATION_MS, EXPAND_HINT_DURATION_MS, } from './constants.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(KeypressProvider, { config: config, children: _jsx(AppContainer, { config: config, version: version, initializationResult: initResult, startupWarnings: startupWarnings, resumedSessionData: resumedSessionData }) }) }));
+    const getAppContainer = ({ settings = mockSettings, config = mockConfig, version = '1.0.0', initResult = mockInitResult, startupWarnings, resumedSessionData, } = {}) => (_jsx(SettingsContext.Provider, { value: settings, children: _jsx(KeypressProvider, { config: config, children: _jsx(OverflowProvider, { 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
@@ -200,6 +218,7 @@ describe('AppContainer State Management', () => {
     const mockedUseHookDisplayState = useHookDisplayState;
     const mockedUseTerminalTheme = useTerminalTheme;
     const mockedUseShellInactivityStatus = useShellInactivityStatus;
+    const mockedUseFocusState = useFocus;
     const DEFAULT_GEMINI_STREAM_MOCK = {
         streamingState: 'idle',
         submitQuery: vi.fn(),
@@ -330,6 +349,10 @@ describe('AppContainer State Management', () => {
             shouldShowFocusHint: false,
             inactivityStatus: 'none',
         });
+        mockedUseFocusState.mockReturnValue({
+            isFocused: true,
+            hasReceivedFocusEvent: true,
+        });
         // Mock Config
         mockConfig = makeFakeConfig();
         // Mock config's getTargetDir to return consistent workspace directory
@@ -384,7 +407,18 @@ describe('AppContainer State Management', () => {
             unmount();
         });
         it('renders with startup warnings', async () => {
-            const startupWarnings = ['Warning 1', 'Warning 2'];
+            const startupWarnings = [
+                {
+                    id: 'w1',
+                    message: 'Warning 1',
+                    priority: WarningPriority.High,
+                },
+                {
+                    id: 'w2',
+                    message: 'Warning 2',
+                    priority: WarningPriority.High,
+                },
+            ];
             let unmount;
             await act(async () => {
                 const result = renderAppContainer({ startupWarnings });
@@ -421,6 +455,286 @@ describe('AppContainer State Management', () => {
         });
     });
     describe('State Initialization', () => {
+        it('sends a macOS notification when confirmation is pending and terminal is unfocused', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: false,
+                hasReceivedFocusEvent: true,
+            });
+            mockedUseGeminiStream.mockReturnValue({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                pendingHistoryItems: [
+                    {
+                        type: 'tool_group',
+                        tools: [
+                            {
+                                callId: 'call-1',
+                                name: 'run_shell_command',
+                                description: 'Run command',
+                                resultDisplay: undefined,
+                                status: CoreToolCallStatus.AwaitingApproval,
+                                confirmationDetails: {
+                                    type: 'exec',
+                                    title: 'Run shell command',
+                                    command: 'ls',
+                                    rootCommand: 'ls',
+                                    rootCommands: ['ls'],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+            let unmount;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+            });
+            await waitFor(() => expect(terminalNotificationsMocks.notifyViaTerminal).toHaveBeenCalled());
+            expect(terminalNotificationsMocks.buildRunEventNotificationContent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'attention',
+            }));
+            await act(async () => {
+                unmount?.();
+            });
+        });
+        it('does not send attention notification when terminal is focused', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: true,
+                hasReceivedFocusEvent: true,
+            });
+            mockedUseGeminiStream.mockReturnValue({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                pendingHistoryItems: [
+                    {
+                        type: 'tool_group',
+                        tools: [
+                            {
+                                callId: 'call-2',
+                                name: 'run_shell_command',
+                                description: 'Run command',
+                                resultDisplay: undefined,
+                                status: CoreToolCallStatus.AwaitingApproval,
+                                confirmationDetails: {
+                                    type: 'exec',
+                                    title: 'Run shell command',
+                                    command: 'ls',
+                                    rootCommand: 'ls',
+                                    rootCommands: ['ls'],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+            let unmount;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+            });
+            expect(terminalNotificationsMocks.notifyViaTerminal).not.toHaveBeenCalled();
+            await act(async () => {
+                unmount?.();
+            });
+        });
+        it('sends attention notification when focus reporting is unavailable', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: true,
+                hasReceivedFocusEvent: false,
+            });
+            mockedUseGeminiStream.mockReturnValue({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                pendingHistoryItems: [
+                    {
+                        type: 'tool_group',
+                        tools: [
+                            {
+                                callId: 'call-focus-unknown',
+                                name: 'run_shell_command',
+                                description: 'Run command',
+                                resultDisplay: undefined,
+                                status: CoreToolCallStatus.AwaitingApproval,
+                                confirmationDetails: {
+                                    type: 'exec',
+                                    title: 'Run shell command',
+                                    command: 'ls',
+                                    rootCommand: 'ls',
+                                    rootCommands: ['ls'],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+            let unmount;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+            });
+            await waitFor(() => expect(terminalNotificationsMocks.notifyViaTerminal).toHaveBeenCalled());
+            await act(async () => {
+                unmount?.();
+            });
+        });
+        it('sends a macOS notification when a response completes while unfocused', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: false,
+                hasReceivedFocusEvent: true,
+            });
+            let currentStreamingState = 'responding';
+            mockedUseGeminiStream.mockImplementation(() => ({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                streamingState: currentStreamingState,
+            }));
+            let unmount;
+            let rerender;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+                rerender = rendered.rerender;
+            });
+            currentStreamingState = 'idle';
+            await act(async () => {
+                rerender?.(getAppContainer());
+            });
+            await waitFor(() => expect(terminalNotificationsMocks.buildRunEventNotificationContent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'session_complete',
+                detail: 'Gemini CLI finished responding.',
+            })));
+            expect(terminalNotificationsMocks.notifyViaTerminal).toHaveBeenCalled();
+            await act(async () => {
+                unmount?.();
+            });
+        });
+        it('sends completion notification when focus reporting is unavailable', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: true,
+                hasReceivedFocusEvent: false,
+            });
+            let currentStreamingState = 'responding';
+            mockedUseGeminiStream.mockImplementation(() => ({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                streamingState: currentStreamingState,
+            }));
+            let unmount;
+            let rerender;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+                rerender = rendered.rerender;
+            });
+            currentStreamingState = 'idle';
+            await act(async () => {
+                rerender?.(getAppContainer());
+            });
+            await waitFor(() => expect(terminalNotificationsMocks.buildRunEventNotificationContent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'session_complete',
+                detail: 'Gemini CLI finished responding.',
+            })));
+            await act(async () => {
+                unmount?.();
+            });
+        });
+        it('does not send completion notification when another action-required dialog is pending', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: false,
+                hasReceivedFocusEvent: true,
+            });
+            mockedUseQuotaAndFallback.mockReturnValue({
+                proQuotaRequest: { kind: 'upgrade' },
+                handleProQuotaChoice: vi.fn(),
+            });
+            let currentStreamingState = 'responding';
+            mockedUseGeminiStream.mockImplementation(() => ({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                streamingState: currentStreamingState,
+            }));
+            let unmount;
+            let rerender;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+                rerender = rendered.rerender;
+            });
+            currentStreamingState = 'idle';
+            await act(async () => {
+                rerender?.(getAppContainer());
+            });
+            expect(terminalNotificationsMocks.notifyViaTerminal).not.toHaveBeenCalled();
+            await act(async () => {
+                unmount?.();
+            });
+        });
+        it('can send repeated attention notifications for the same key after pending state clears', async () => {
+            mockedUseFocusState.mockReturnValue({
+                isFocused: false,
+                hasReceivedFocusEvent: true,
+            });
+            let pendingHistoryItems = [
+                {
+                    type: 'tool_group',
+                    tools: [
+                        {
+                            callId: 'repeat-key-call',
+                            name: 'run_shell_command',
+                            description: 'Run command',
+                            resultDisplay: undefined,
+                            status: CoreToolCallStatus.AwaitingApproval,
+                            confirmationDetails: {
+                                type: 'exec',
+                                title: 'Run shell command',
+                                command: 'ls',
+                                rootCommand: 'ls',
+                                rootCommands: ['ls'],
+                            },
+                        },
+                    ],
+                },
+            ];
+            mockedUseGeminiStream.mockImplementation(() => ({
+                ...DEFAULT_GEMINI_STREAM_MOCK,
+                pendingHistoryItems,
+            }));
+            let unmount;
+            let rerender;
+            await act(async () => {
+                const rendered = renderAppContainer();
+                unmount = rendered.unmount;
+                rerender = rendered.rerender;
+            });
+            await waitFor(() => expect(terminalNotificationsMocks.notifyViaTerminal).toHaveBeenCalledTimes(1));
+            pendingHistoryItems = [];
+            await act(async () => {
+                rerender?.(getAppContainer());
+            });
+            pendingHistoryItems = [
+                {
+                    type: 'tool_group',
+                    tools: [
+                        {
+                            callId: 'repeat-key-call',
+                            name: 'run_shell_command',
+                            description: 'Run command',
+                            resultDisplay: undefined,
+                            status: CoreToolCallStatus.AwaitingApproval,
+                            confirmationDetails: {
+                                type: 'exec',
+                                title: 'Run shell command',
+                                command: 'ls',
+                                rootCommand: 'ls',
+                                rootCommands: ['ls'],
+                            },
+                        },
+                    ],
+                },
+            ];
+            await act(async () => {
+                rerender?.(getAppContainer());
+            });
+            await waitFor(() => expect(terminalNotificationsMocks.notifyViaTerminal).toHaveBeenCalledTimes(2));
+            await act(async () => {
+                unmount?.();
+            });
+        });
         it('initializes with theme error from initialization result', async () => {
             const initResultWithError = {
                 ...mockInitResult,
@@ -1853,7 +2167,7 @@ describe('AppContainer State Management', () => {
                 });
                 return null;
             }
-            const getTree = (settings) => (_jsx(SettingsContext.Provider, { value: settings, children: _jsxs(KeypressProvider, { config: mockConfig, children: [_jsx(AppContainer, { config: mockConfig, version: "1.0.0", initializationResult: mockInitResult }), _jsx(TestChild, {})] }) }));
+            const getTree = (settings) => (_jsx(SettingsContext.Provider, { value: settings, children: _jsx(KeypressProvider, { config: mockConfig, children: _jsxs(OverflowProvider, { children: [_jsx(AppContainer, { config: mockConfig, version: "1.0.0", initializationResult: mockInitResult }), _jsx(TestChild, {})] }) }) }));
             const renderResult = render(getTree(testSettings));
             stdin = renderResult.stdin;
             await act(async () => {
@@ -2323,6 +2637,246 @@ describe('AppContainer State Management', () => {
             compUnmount();
         });
     });
+    describe('Submission Handling', () => {
+        it('resets expansion state on submission when not in alternate buffer', async () => {
+            const { checkPermissions } = await import('./hooks/atCommandProcessor.js');
+            vi.mocked(checkPermissions).mockResolvedValue([]);
+            let unmount;
+            await act(async () => {
+                unmount = renderAppContainer({
+                    settings: {
+                        ...mockSettings,
+                        merged: {
+                            ...mockSettings.merged,
+                            ui: { ...mockSettings.merged.ui, useAlternateBuffer: false },
+                        },
+                    },
+                }).unmount;
+            });
+            await waitFor(() => expect(capturedUIActions).toBeTruthy());
+            // Expand first
+            act(() => capturedUIActions.setConstrainHeight(false));
+            expect(capturedUIState.constrainHeight).toBe(false);
+            // Reset mock stdout to clear any initial writes
+            mocks.mockStdout.write.mockClear();
+            // Submit
+            await act(async () => capturedUIActions.handleFinalSubmit('test prompt'));
+            // Should be reset
+            expect(capturedUIState.constrainHeight).toBe(true);
+            // Should refresh static (which clears terminal in non-alternate buffer)
+            expect(mocks.mockStdout.write).toHaveBeenCalledWith(ansiEscapes.clearTerminal);
+            unmount();
+        });
+        it('resets expansion state on submission when in alternate buffer without clearing terminal', async () => {
+            const { checkPermissions } = await import('./hooks/atCommandProcessor.js');
+            vi.mocked(checkPermissions).mockResolvedValue([]);
+            let unmount;
+            await act(async () => {
+                unmount = renderAppContainer({
+                    settings: {
+                        ...mockSettings,
+                        merged: {
+                            ...mockSettings.merged,
+                            ui: { ...mockSettings.merged.ui, useAlternateBuffer: true },
+                        },
+                    },
+                }).unmount;
+            });
+            await waitFor(() => expect(capturedUIActions).toBeTruthy());
+            // Expand first
+            act(() => capturedUIActions.setConstrainHeight(false));
+            expect(capturedUIState.constrainHeight).toBe(false);
+            // Reset mock stdout
+            mocks.mockStdout.write.mockClear();
+            // Submit
+            await act(async () => capturedUIActions.handleFinalSubmit('test prompt'));
+            // Should be reset
+            expect(capturedUIState.constrainHeight).toBe(true);
+            // Should NOT refresh static's clearTerminal in alternate buffer
+            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(ansiEscapes.clearTerminal);
+            unmount();
+        });
+    });
+    describe('Overflow Hint Handling', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('sets showIsExpandableHint when overflow occurs in Standard Mode and hides after 10s', async () => {
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
+            await waitFor(() => expect(capturedUIState).toBeTruthy());
+            // Trigger overflow
+            act(() => {
+                capturedOverflowActions.addOverflowingId('test-id');
+            });
+            await waitFor(() => {
+                // Should show hint because we are in Standard Mode (default settings) and have overflow
+                expect(capturedUIState.showIsExpandableHint).toBe(true);
+            });
+            // Advance just before the timeout
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS - 100);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Advance to hit the timeout mark
+            act(() => {
+                vi.advanceTimersByTime(100);
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(false);
+            });
+            unmount();
+        });
+        it('toggles expansion state and resets the hint timer when Ctrl+O is pressed in Standard Mode', async () => {
+            let unmount;
+            let stdin;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+                stdin = result.stdin;
+            });
+            await waitFor(() => expect(capturedUIState).toBeTruthy());
+            // Initial state is constrainHeight = true
+            expect(capturedUIState.constrainHeight).toBe(true);
+            // Trigger overflow so the hint starts showing
+            act(() => {
+                capturedOverflowActions.addOverflowingId('test-id');
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(true);
+            });
+            // Advance half the duration
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS / 2);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Simulate Ctrl+O
+            act(() => {
+                stdin.write('\x0f'); // \x0f is Ctrl+O
+            });
+            await waitFor(() => {
+                // constrainHeight should toggle
+                expect(capturedUIState.constrainHeight).toBe(false);
+            });
+            // Advance enough that the original timer would have expired if it hadn't reset
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS / 2 + 1000);
+            });
+            // We expect it to still be true because Ctrl+O should have reset the timer
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Advance remaining time to reach the new timeout
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS / 2 - 1000);
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(false);
+            });
+            unmount();
+        });
+        it('toggles Ctrl+O multiple times and verifies the hint disappears exactly after the last toggle', async () => {
+            let unmount;
+            let stdin;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+                stdin = result.stdin;
+            });
+            await waitFor(() => expect(capturedUIState).toBeTruthy());
+            // Initial state is constrainHeight = true
+            expect(capturedUIState.constrainHeight).toBe(true);
+            // Trigger overflow so the hint starts showing
+            act(() => {
+                capturedOverflowActions.addOverflowingId('test-id');
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(true);
+            });
+            // Advance half the duration
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS / 2);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // First toggle 'on' (expanded)
+            act(() => {
+                stdin.write('\x0f'); // Ctrl+O
+            });
+            await waitFor(() => {
+                expect(capturedUIState.constrainHeight).toBe(false);
+            });
+            // Wait 1 second
+            act(() => {
+                vi.advanceTimersByTime(1000);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Second toggle 'off' (collapsed)
+            act(() => {
+                stdin.write('\x0f'); // Ctrl+O
+            });
+            await waitFor(() => {
+                expect(capturedUIState.constrainHeight).toBe(true);
+            });
+            // Wait 1 second
+            act(() => {
+                vi.advanceTimersByTime(1000);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Third toggle 'on' (expanded)
+            act(() => {
+                stdin.write('\x0f'); // Ctrl+O
+            });
+            await waitFor(() => {
+                expect(capturedUIState.constrainHeight).toBe(false);
+            });
+            // Now we wait just before the timeout from the LAST toggle.
+            // It should still be true.
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS - 100);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Wait 0.1s more to hit exactly the timeout since the last toggle.
+            // It should hide now.
+            act(() => {
+                vi.advanceTimersByTime(100);
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(false);
+            });
+            unmount();
+        });
+        it('does NOT set showIsExpandableHint when overflow occurs in Alternate Buffer Mode', async () => {
+            const alternateSettings = mergeSettings({}, {}, {}, {}, true);
+            const settingsWithAlternateBuffer = {
+                merged: {
+                    ...alternateSettings,
+                    ui: {
+                        ...alternateSettings.ui,
+                        useAlternateBuffer: true,
+                    },
+                },
+            };
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({
+                    settings: settingsWithAlternateBuffer,
+                });
+                unmount = result.unmount;
+            });
+            await waitFor(() => expect(capturedUIState).toBeTruthy());
+            // Trigger overflow
+            act(() => {
+                capturedOverflowActions.addOverflowingId('test-id');
+            });
+            // Should NOT show hint because we are in Alternate Buffer Mode
+            expect(capturedUIState.showIsExpandableHint).toBe(false);
+            unmount();
+        });
+    });
     describe('Permission Handling', () => {
         it('shows permission dialog when checkPermissions returns paths', async () => {
             const { checkPermissions } = await import('./hooks/atCommandProcessor.js');