@quantum-ai/gemini-cli 0.45.3 → 0.45.4

package/packages/cli/dist/src/ui/components/InputPrompt.test.js

@@ -1,4077 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { renderWithProviders, cleanup } from '../../test-utils/render.js';
-import { createMockSettings } from '../../test-utils/settings.js';
-import { makeFakeConfig } from '@quantum-ai/gemini-cli-core';
-import { waitFor } from '../../test-utils/async.js';
-import { act, useState, useMemo } from 'react';
-const { fakeTranscriptionProvider } = vi.hoisted(() => {
-    // Use require within hoisted block for immediate synchronous access
-    // eslint-disable-next-line @typescript-eslint/no-require-imports, no-restricted-syntax
-    const { EventEmitter } = require('node:events');
-    class FakeTranscriptionProvider extends EventEmitter {
-        connect = vi.fn().mockResolvedValue(undefined);
-        disconnect = vi.fn();
-        sendAudioChunk = vi.fn();
-        getTranscription = vi.fn().mockReturnValue('');
-    }
-    return {
-        fakeTranscriptionProvider: new FakeTranscriptionProvider(),
-    };
-});
-vi.mock('@quantum-ai/gemini-cli-core', async (importOriginal) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const actual = (await importOriginal());
-    return {
-        ...actual,
-        TranscriptionFactory: {
-            createProvider: vi.fn(() => fakeTranscriptionProvider),
-        },
-    };
-});
-import { InputPrompt, tryTogglePasteExpansion, } from './InputPrompt.js';
-import { InputContext } from '../contexts/InputContext.js';
-import {} from '../contexts/UIStateContext.js';
-import { calculateTransformationsForLine, calculateTransformedLine, } from './shared/text-buffer.js';
-import { ApprovalMode, debugLogger, coreEvents, } from '@quantum-ai/gemini-cli-core';
-import * as path from 'node:path';
-import { CommandKind, } from '../commands/types.js';
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { Text } from 'ink';
-import { useShellHistory, } from '../hooks/useShellHistory.js';
-import { useCommandCompletion, CompletionMode, } from '../hooks/useCommandCompletion.js';
-import { useInputHistory, } from '../hooks/useInputHistory.js';
-import { useReverseSearchCompletion, } from '../hooks/useReverseSearchCompletion.js';
-import clipboardy from 'clipboardy';
-import * as clipboardUtils from '../utils/clipboardUtils.js';
-import { useKittyKeyboardProtocol } from '../hooks/useKittyKeyboardProtocol.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import stripAnsi from 'strip-ansi';
-import { StreamingState } from '../types.js';
-import { terminalCapabilityManager } from '../utils/terminalCapabilityManager.js';
-import { cpLen } from '../utils/textUtils.js';
-import { defaultKeyMatchers, Command } from '../key/keyMatchers.js';
-import { useKeypress } from '../hooks/useKeypress.js';
-import { appEvents, AppEvent, TransientMessageType, } from '../../utils/events.js';
-import '../../test-utils/customMatchers.js';
-vi.mock('../hooks/useShellHistory.js');
-vi.mock('../hooks/useCommandCompletion.js');
-vi.mock('../hooks/useInputHistory.js');
-vi.mock('../hooks/useReverseSearchCompletion.js');
-vi.mock('clipboardy');
-vi.mock('../utils/clipboardUtils.js');
-vi.mock('../hooks/useKittyKeyboardProtocol.js');
-vi.mock('./ListeningIndicator.js', () => ({
-    ListeningIndicator: vi.fn(({ color }) => _jsx(Text, { color: color, children: "~~~ " })),
-}));
-// Mock ink BEFORE importing components that use it to intercept terminalCursorPosition
-vi.mock('ink', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        Text: vi.fn(({ children, ...props }) => (_jsx(actual.Text, { ...props, children: children }))),
-    };
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-    cleanup();
-});
-const mockSlashCommands = [
-    {
-        name: 'stats',
-        description: 'Check stats',
-        kind: CommandKind.BUILT_IN,
-        isSafeConcurrent: true,
-    },
-    {
-        name: 'clear',
-        kind: CommandKind.BUILT_IN,
-        description: 'Clear screen',
-        action: vi.fn(),
-    },
-    {
-        name: 'memory',
-        kind: CommandKind.BUILT_IN,
-        description: 'Manage memory',
-        subCommands: [
-            {
-                name: 'show',
-                kind: CommandKind.BUILT_IN,
-                description: 'Show memory',
-                action: vi.fn(),
-            },
-            {
-                name: 'add',
-                kind: CommandKind.BUILT_IN,
-                description: 'Add to memory',
-                action: vi.fn(),
-            },
-            {
-                name: 'refresh',
-                kind: CommandKind.BUILT_IN,
-                description: 'Refresh memory',
-                action: vi.fn(),
-            },
-        ],
-    },
-    {
-        name: 'chat',
-        description: 'Manage chats',
-        kind: CommandKind.BUILT_IN,
-        subCommands: [
-            {
-                name: 'resume',
-                description: 'Resume a chat',
-                kind: CommandKind.BUILT_IN,
-                action: vi.fn(),
-                completion: async () => ['fix-foo', 'fix-bar'],
-            },
-        ],
-    },
-    {
-        name: 'resume',
-        description: 'Browse and resume sessions',
-        kind: CommandKind.BUILT_IN,
-        action: vi.fn(),
-    },
-];
-const TestInputPrompt = (props) => {
-    const contextValue = useMemo(() => ({
-        buffer: props.buffer,
-        userMessages: props.userMessages,
-        shellModeActive: props.shellModeActive,
-        copyModeEnabled: props.copyModeEnabled,
-        showEscapePrompt: props.showEscapePrompt || false,
-        inputWidth: props.inputWidth,
-        suggestionsWidth: props.suggestionsWidth,
-    }), [
-        props.buffer,
-        props.userMessages,
-        props.shellModeActive,
-        props.copyModeEnabled,
-        props.showEscapePrompt,
-        props.inputWidth,
-        props.suggestionsWidth,
-    ]);
-    return (_jsx(InputContext.Provider, { value: contextValue, children: _jsx(InputPrompt, { ...props }) }));
-};
-describe('InputPrompt', () => {
-    let props;
-    let mockShellHistory;
-    let mockCommandCompletion;
-    let mockInputHistory;
-    let mockReverseSearchCompletion;
-    let mockBuffer;
-    let mockCommandContext;
-    const GlobalEscapeHandler = ({ onEscape }) => {
-        useKeypress((key) => {
-            if (key.name !== 'escape')
-                return false;
-            onEscape();
-            return true;
-        }, { isActive: true, priority: false });
-        return null;
-    };
-    const mockedUseShellHistory = vi.mocked(useShellHistory);
-    const mockedUseCommandCompletion = vi.mocked(useCommandCompletion);
-    const mockedUseInputHistory = vi.mocked(useInputHistory);
-    const mockedUseReverseSearchCompletion = vi.mocked(useReverseSearchCompletion);
-    const mockedUseKittyKeyboardProtocol = vi.mocked(useKittyKeyboardProtocol);
-    const mockSetEmbeddedShellFocused = vi.fn();
-    const mockSetCleanUiDetailsVisible = vi.fn();
-    const mockToggleCleanUiDetailsVisible = vi.fn();
-    const mockRevealCleanUiDetailsTemporarily = vi.fn();
-    const uiActions = {
-        setEmbeddedShellFocused: mockSetEmbeddedShellFocused,
-        setCleanUiDetailsVisible: mockSetCleanUiDetailsVisible,
-        toggleCleanUiDetailsVisible: mockToggleCleanUiDetailsVisible,
-        revealCleanUiDetailsTemporarily: mockRevealCleanUiDetailsTemporarily,
-        addMessage: vi.fn(),
-    };
-    beforeEach(() => {
-        vi.resetAllMocks();
-        coreEvents.removeAllListeners();
-        vi.spyOn(terminalCapabilityManager, 'isKittyProtocolEnabled').mockReturnValue(true);
-        mockCommandContext = createMockCommandContext();
-        mockBuffer = {
-            text: '',
-            cursor: [0, 0],
-            lines: [''],
-            setText: vi.fn((newText, cursorPosition) => {
-                mockBuffer.text = newText;
-                mockBuffer.lines = newText.split('\n');
-                let col = 0;
-                if (typeof cursorPosition === 'number') {
-                    col = cursorPosition;
-                }
-                else if (cursorPosition === 'start') {
-                    col = 0;
-                }
-                else {
-                    col = newText.length;
-                }
-                mockBuffer.cursor = [0, col];
-                mockBuffer.allVisualLines = newText.split('\n');
-                mockBuffer.viewportVisualLines = newText.split('\n');
-                mockBuffer.visualToLogicalMap = newText
-                    .split('\n')
-                    .map((_, i) => [i, 0]);
-                mockBuffer.visualCursor = [0, col];
-                mockBuffer.visualScrollRow = 0;
-                mockBuffer.viewportHeight = 10;
-                mockBuffer.visualToTransformedMap = newText
-                    .split('\n')
-                    .map((_, i) => i);
-                mockBuffer.transformationsByLine = newText.split('\n').map(() => []);
-            }),
-            replaceRangeByOffset: vi.fn(),
-            viewportVisualLines: [''],
-            allVisualLines: [''],
-            visualCursor: [0, 0],
-            visualScrollRow: 0,
-            viewportHeight: 10,
-            handleInput: vi.fn((key) => {
-                if (defaultKeyMatchers[Command.CLEAR_INPUT](key)) {
-                    if (mockBuffer.text.length > 0) {
-                        mockBuffer.setText('');
-                        return true;
-                    }
-                    return false;
-                }
-                return false;
-            }),
-            move: vi.fn((dir) => {
-                if (dir === 'home') {
-                    mockBuffer.visualCursor = [mockBuffer.visualCursor[0], 0];
-                }
-                else if (dir === 'end') {
-                    const line = mockBuffer.allVisualLines[mockBuffer.visualCursor[0]] || '';
-                    mockBuffer.visualCursor = [mockBuffer.visualCursor[0], cpLen(line)];
-                }
-            }),
-            moveToOffset: vi.fn((offset) => {
-                mockBuffer.cursor = [0, offset];
-            }),
-            moveToVisualPosition: vi.fn(),
-            killLineRight: vi.fn(),
-            killLineLeft: vi.fn(),
-            openInExternalEditor: vi.fn(),
-            newline: vi.fn(),
-            undo: vi.fn(),
-            redo: vi.fn(),
-            backspace: vi.fn(),
-            preferredCol: null,
-            selectionAnchor: null,
-            insert: vi.fn(),
-            del: vi.fn(),
-            replaceRange: vi.fn(),
-            deleteWordLeft: vi.fn(),
-            deleteWordRight: vi.fn(),
-            visualToLogicalMap: [[0, 0]],
-            visualToTransformedMap: [0],
-            transformationsByLine: [],
-            getOffset: vi.fn().mockImplementation(() => mockBuffer.cursor[1]),
-            pastedContent: {},
-        };
-        mockShellHistory = {
-            history: [],
-            addCommandToHistory: vi.fn(),
-            getPreviousCommand: vi.fn().mockReturnValue(null),
-            getNextCommand: vi.fn().mockReturnValue(null),
-            resetHistoryPosition: vi.fn(),
-        };
-        mockedUseShellHistory.mockReturnValue(mockShellHistory);
-        mockCommandCompletion = {
-            suggestions: [],
-            activeSuggestionIndex: -1,
-            isLoadingSuggestions: false,
-            showSuggestions: false,
-            visibleStartIndex: 0,
-            isPerfectMatch: false,
-            navigateUp: vi.fn(),
-            navigateDown: vi.fn(),
-            resetCompletionState: vi.fn(),
-            setActiveSuggestionIndex: vi.fn(),
-            handleAutocomplete: vi.fn(),
-            promptCompletion: {
-                text: '',
-                accept: vi.fn(),
-                clear: vi.fn(),
-                isLoading: false,
-                isActive: false,
-                markSelected: vi.fn(),
-            },
-            getCommandFromSuggestion: vi.fn().mockReturnValue(undefined),
-            slashCompletionRange: {
-                completionStart: -1,
-                completionEnd: -1,
-                getCommandFromSuggestion: vi.fn().mockReturnValue(undefined),
-                isArgumentCompletion: false,
-                leafCommand: null,
-            },
-            getCompletedText: vi.fn().mockReturnValue(null),
-            completionMode: CompletionMode.IDLE,
-            forceShowShellSuggestions: false,
-            setForceShowShellSuggestions: vi.fn(),
-            isShellSuggestionsVisible: true,
-        };
-        mockedUseCommandCompletion.mockReturnValue(mockCommandCompletion);
-        mockInputHistory = {
-            navigateUp: vi.fn(),
-            navigateDown: vi.fn(),
-            handleSubmit: vi.fn(),
-        };
-        mockedUseInputHistory.mockImplementation(({ onSubmit }) => {
-            mockInputHistory.handleSubmit = vi.fn((val) => onSubmit(val));
-            return mockInputHistory;
-        });
-        mockReverseSearchCompletion = {
-            suggestions: [],
-            activeSuggestionIndex: -1,
-            visibleStartIndex: 0,
-            showSuggestions: false,
-            isLoadingSuggestions: false,
-            navigateUp: vi.fn(),
-            navigateDown: vi.fn(),
-            handleAutocomplete: vi.fn(),
-            resetCompletionState: vi.fn(),
-        };
-        mockedUseReverseSearchCompletion.mockReturnValue(mockReverseSearchCompletion);
-        mockedUseKittyKeyboardProtocol.mockReturnValue({
-            enabled: false,
-            checking: false,
-        });
-        vi.mocked(clipboardy.read).mockResolvedValue('');
-        props = {
-            onQueueMessage: vi.fn(),
-            buffer: mockBuffer,
-            onSubmit: vi.fn(),
-            userMessages: [],
-            onClearScreen: vi.fn(),
-            config: {
-                getProjectRoot: () => path.join('test', 'project'),
-                getTargetDir: () => path.join('test', 'project', 'src'),
-                getVimMode: () => false,
-                getUseBackgroundColor: () => true,
-                getUseTerminalBuffer: () => false,
-                getTerminalBackground: () => undefined,
-                getWorkspaceContext: () => ({
-                    getDirectories: () => ['/test/project/src'],
-                }),
-                getContentGeneratorConfig: () => ({ apiKey: 'test-api-key' }),
-            },
-            slashCommands: mockSlashCommands,
-            commandContext: mockCommandContext,
-            shellModeActive: false,
-            setShellModeActive: vi.fn(),
-            approvalMode: ApprovalMode.DEFAULT,
-            inputWidth: 80,
-            suggestionsWidth: 80,
-            focus: true,
-            setQueueErrorMessage: vi.fn(),
-            streamingState: StreamingState.Idle,
-            setBannerVisible: vi.fn(),
-        };
-    });
-    it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => {
-        props.shellModeActive = true;
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[A');
-        });
-        await waitFor(() => expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled());
-        unmount();
-    });
-    it('should call shellHistory.getNextCommand on down arrow in shell mode', async () => {
-        props.shellModeActive = true;
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[B');
-            await waitFor(() => expect(mockShellHistory.getNextCommand).toHaveBeenCalled());
-        });
-        unmount();
-    });
-    it('should set the buffer text when a shell history command is retrieved', async () => {
-        props.shellModeActive = true;
-        vi.mocked(mockShellHistory.getPreviousCommand).mockReturnValue('previous command');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[A');
-        });
-        await waitFor(() => {
-            expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
-            expect(props.buffer.setText).toHaveBeenCalledWith('previous command');
-        });
-        unmount();
-    });
-    it('should call shellHistory.addCommandToHistory on submit in shell mode', async () => {
-        props.shellModeActive = true;
-        props.buffer.setText('ls -l');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith('ls -l');
-            expect(props.onSubmit).toHaveBeenCalledWith('ls -l');
-        });
-        unmount();
-    });
-    it('should submit command in shell mode when Enter pressed with suggestions visible but no arrow navigation', async () => {
-        props.shellModeActive = true;
-        props.buffer.setText('ls ');
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'dir1', value: 'dir1' },
-                { label: 'dir2', value: 'dir2' },
-            ],
-            activeSuggestionIndex: 0,
-        });
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        // Press Enter without navigating — should dismiss suggestions and fall
-        // through to the main submit handler.
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-            expect(props.onSubmit).toHaveBeenCalledWith('ls'); // Assert fall-through (text is trimmed)
-        });
-        expect(mockCommandCompletion.handleAutocomplete).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should accept suggestion in shell mode when Enter pressed after arrow navigation', async () => {
-        props.shellModeActive = true;
-        props.buffer.setText('ls ');
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'dir1', value: 'dir1' },
-                { label: 'dir2', value: 'dir2' },
-            ],
-            activeSuggestionIndex: 1,
-        });
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        // Press ArrowDown to navigate, then Enter to accept
-        await act(async () => {
-            stdin.write('\u001B[B'); // ArrowDown — sets hasUserNavigatedSuggestions
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\r'); // Enter — should accept navigated suggestion
-        });
-        await waitFor(() => {
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1);
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should NOT call shell history methods when not in shell mode', async () => {
-        props.buffer.setText('some text');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u0010'); // Ctrl+P
-        });
-        await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\u000E'); // Ctrl+N
-        });
-        await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('some text'));
-        expect(mockShellHistory.getPreviousCommand).not.toHaveBeenCalled();
-        expect(mockShellHistory.getNextCommand).not.toHaveBeenCalled();
-        expect(mockShellHistory.addCommandToHistory).not.toHaveBeenCalled();
-        unmount();
-    });
-    describe('arrow key navigation', () => {
-        it('should move to start of line on Up arrow if on first line but not at start', async () => {
-            mockBuffer.allVisualLines = ['line 1', 'line 2'];
-            mockBuffer.visualCursor = [0, 5]; // First line, not at start
-            mockBuffer.visualScrollRow = 0;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\u001B[A'); // Up arrow
-            });
-            await waitFor(() => {
-                expect(mockBuffer.move).toHaveBeenCalledWith('home');
-                expect(mockInputHistory.navigateUp).not.toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should navigate history on Up arrow if on first line and at start', async () => {
-            mockBuffer.allVisualLines = ['line 1', 'line 2'];
-            mockBuffer.visualCursor = [0, 0]; // First line, at start
-            mockBuffer.visualScrollRow = 0;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\u001B[A'); // Up arrow
-            });
-            await waitFor(() => {
-                expect(mockBuffer.move).not.toHaveBeenCalledWith('home');
-                expect(mockInputHistory.navigateUp).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should move to end of line on Down arrow if on last line but not at end', async () => {
-            mockBuffer.allVisualLines = ['line 1', 'line 2'];
-            mockBuffer.visualCursor = [1, 0]; // Last line, not at end
-            mockBuffer.visualScrollRow = 0;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\u001B[B'); // Down arrow
-            });
-            await waitFor(() => {
-                expect(mockBuffer.move).toHaveBeenCalledWith('end');
-                expect(mockInputHistory.navigateDown).not.toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should navigate history on Down arrow if on last line and at end', async () => {
-            mockBuffer.allVisualLines = ['line 1', 'line 2'];
-            mockBuffer.visualCursor = [1, 6]; // Last line, at end ("line 2" is length 6)
-            mockBuffer.visualScrollRow = 0;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\u001B[B'); // Down arrow
-            });
-            await waitFor(() => {
-                expect(mockBuffer.move).not.toHaveBeenCalledWith('end');
-                expect(mockInputHistory.navigateDown).toHaveBeenCalled();
-            });
-            unmount();
-        });
-    });
-    it('should call completion.navigateUp for both up arrow and Ctrl+P when suggestions are showing', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'memory', value: 'memory' },
-                { label: 'memcache', value: 'memcache' },
-            ],
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        // Test up arrow
-        await act(async () => {
-            stdin.write('\u001B[A'); // Up arrow
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(1));
-        await act(async () => {
-            stdin.write('\u0010'); // Ctrl+P
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(2));
-        expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should call completion.navigateDown for both down arrow and Ctrl+N when suggestions are showing', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'memory', value: 'memory' },
-                { label: 'memcache', value: 'memcache' },
-            ],
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        // Test down arrow
-        await act(async () => {
-            stdin.write('\u001B[B'); // Down arrow
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(1));
-        await act(async () => {
-            stdin.write('\u000E'); // Ctrl+N
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(2));
-        expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should NOT call completion navigation when suggestions are not showing', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: false,
-        });
-        props.buffer.setText('some text');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u0010'); // Ctrl+P
-        });
-        await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\u000E'); // Ctrl+N
-        });
-        await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\u0010'); // Ctrl+P
-        });
-        await act(async () => {
-            stdin.write('\u000E'); // Ctrl+N
-        });
-        await waitFor(() => {
-            expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
-            expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should clear the buffer and reset completion on Ctrl+C', async () => {
-        mockBuffer.text = 'some text';
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u0003'); // Ctrl+C
-        });
-        await waitFor(() => {
-            expect(mockBuffer.setText).toHaveBeenCalledWith('');
-            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-        });
-        unmount();
-    });
-    describe('clipboard image paste', () => {
-        beforeEach(() => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
-            vi.mocked(clipboardUtils.cleanupOldClipboardImages).mockResolvedValue(undefined);
-        });
-        it('should handle Ctrl+V when clipboard has an image', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue('/test/.gemini-clipboard/clipboard-123.png');
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            // Send Ctrl+V
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
-                expect(clipboardUtils.saveClipboardImage).toHaveBeenCalledWith(props.config.getTargetDir());
-                expect(clipboardUtils.cleanupOldClipboardImages).toHaveBeenCalledWith(props.config.getTargetDir());
-                expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should not insert anything when clipboard has no image', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
-            });
-            expect(clipboardUtils.saveClipboardImage).not.toHaveBeenCalled();
-            expect(mockBuffer.setText).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should handle image save failure gracefully', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
-            });
-            expect(mockBuffer.setText).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should insert image path at cursor position with proper spacing', async () => {
-            const imagePath = path.join('test', '.gemini-clipboard', 'clipboard-456.png');
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(imagePath);
-            // Set initial text and cursor position
-            mockBuffer.text = 'Hello world';
-            mockBuffer.cursor = [0, 5]; // Cursor after "Hello"
-            vi.mocked(mockBuffer.getOffset).mockReturnValue(5);
-            mockBuffer.lines = ['Hello world'];
-            mockBuffer.replaceRangeByOffset = vi.fn();
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                // Should insert at cursor position with spaces
-                expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
-            });
-            // Get the actual call to see what path was used
-            const actualCall = vi.mocked(mockBuffer.replaceRangeByOffset).mock
-                .calls[0];
-            expect(actualCall[0]).toBe(5); // start offset
-            expect(actualCall[1]).toBe(5); // end offset
-            expect(actualCall[2]).toBe(' @' + path.relative(path.join('test', 'project', 'src'), imagePath));
-            unmount();
-        });
-        it('should handle errors during clipboard operations', async () => {
-            const debugLoggerErrorSpy = vi
-                .spyOn(debugLogger, 'error')
-                .mockImplementation(() => { });
-            vi.mocked(clipboardUtils.clipboardHasImage).mockRejectedValue(new Error('Clipboard error'));
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(debugLoggerErrorSpy).toHaveBeenCalledWith('Error handling paste:', expect.any(Error));
-            });
-            expect(mockBuffer.setText).not.toHaveBeenCalled();
-            debugLoggerErrorSpy.mockRestore();
-            unmount();
-        });
-    });
-    describe('clipboard text paste', () => {
-        it('should insert text from clipboard on Ctrl+V', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            vi.mocked(clipboardy.read).mockResolvedValue('pasted text');
-            vi.mocked(mockBuffer.replaceRangeByOffset).mockClear();
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardy.read).toHaveBeenCalled();
-                expect(mockBuffer.insert).toHaveBeenCalledWith('pasted text', expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should use OSC 52 when useOSC52Paste setting is enabled', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const settings = createMockSettings({
-                experimental: { useOSC52Paste: true },
-            });
-            const { stdout, stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { settings });
-            const writeSpy = vi.spyOn(stdout, 'write');
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(writeSpy).toHaveBeenCalledWith('\x1b]52;c;?\x07');
-            });
-            // Should NOT call clipboardy.read()
-            expect(clipboardy.read).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    it.each([
-        {
-            name: 'should complete a partial parent command',
-            bufferText: '/mem',
-            suggestions: [{ label: 'memory', value: 'memory', description: '...' }],
-            activeIndex: 0,
-        },
-        {
-            name: 'should append a sub-command when parent command is complete',
-            bufferText: '/memory ',
-            suggestions: [
-                { label: 'show', value: 'show' },
-                { label: 'add', value: 'add' },
-            ],
-            activeIndex: 1,
-        },
-        {
-            name: 'should handle the backspace edge case correctly',
-            bufferText: '/memory',
-            suggestions: [
-                { label: 'show', value: 'show' },
-                { label: 'add', value: 'add' },
-            ],
-            activeIndex: 0,
-        },
-        {
-            name: 'should complete a partial argument for a command',
-            bufferText: '/chat resume fi-',
-            suggestions: [{ label: 'fix-foo', value: 'fix-foo' }],
-            activeIndex: 0,
-        },
-    ])('$name', async ({ bufferText, suggestions, activeIndex }) => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions,
-            activeSuggestionIndex: activeIndex,
-        });
-        props.buffer.setText(bufferText);
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => stdin.write('\t'));
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(activeIndex));
-        unmount();
-    });
-    it('should autocomplete on Enter when suggestions are active, without submitting', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'memory', value: 'memory' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            // The app should autocomplete the text, NOT submit.
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should complete a command based on its altNames', async () => {
-        props.slashCommands = [
-            {
-                name: 'help',
-                altNames: ['?'],
-                kind: CommandKind.BUILT_IN,
-                description: '...',
-            },
-        ];
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'help', value: 'help' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('/?');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t'); // Press Tab for autocomplete
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
-        unmount();
-    });
-    it('queues a message when Tab is pressed during generation', async () => {
-        props.buffer.setText('A new prompt');
-        props.streamingState = StreamingState.Responding;
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t');
-        });
-        await waitFor(() => {
-            expect(props.onQueueMessage).toHaveBeenCalledWith('A new prompt');
-            expect(props.buffer.text).toBe('');
-        });
-        unmount();
-    });
-    it('shows an error when attempting to queue a slash command', async () => {
-        props.buffer.setText('/clear');
-        props.streamingState = StreamingState.Responding;
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t');
-        });
-        await waitFor(() => {
-            expect(props.setQueueErrorMessage).toHaveBeenCalledWith('Slash commands cannot be queued');
-            expect(props.onQueueMessage).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('shows an error when attempting to queue a shell command', async () => {
-        props.shellModeActive = true;
-        props.buffer.setText('ls');
-        props.streamingState = StreamingState.Responding;
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t');
-        });
-        await waitFor(() => {
-            expect(props.setQueueErrorMessage).toHaveBeenCalledWith('Shell commands cannot be queued');
-            expect(props.onQueueMessage).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should not submit on Enter when the buffer is empty or only contains whitespace', async () => {
-        props.buffer.setText('   '); // Set buffer to whitespace
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Press Enter
-        });
-        await waitFor(() => {
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should submit directly on Enter when isPerfectMatch is true', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: false,
-            isPerfectMatch: true,
-        });
-        props.buffer.setText('/clear');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('/clear'));
-        unmount();
-    });
-    it('should execute perfect match on Enter even if suggestions are showing, if at first suggestion', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'review', value: 'review' }, // Match is now at index 0
-                { label: 'review-frontend', value: 'review-frontend' },
-            ],
-            activeSuggestionIndex: 0,
-            isPerfectMatch: true,
-        });
-        props.buffer.text = '/review';
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(props.onSubmit).toHaveBeenCalledWith('/review');
-        });
-        unmount();
-    });
-    it('should autocomplete and NOT execute on Enter if a DIFFERENT suggestion is selected even if perfect match', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'review', value: 'review' },
-                { label: 'review-frontend', value: 'review-frontend' },
-            ],
-            activeSuggestionIndex: 1, // review-frontend selected (not the perfect match at 0)
-            isPerfectMatch: true, // /review is a perfect match
-        });
-        props.buffer.text = '/review';
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            // Should handle autocomplete for index 1
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1);
-            // Should NOT submit
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should submit directly on Enter when a complete leaf command is typed', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: false,
-            isPerfectMatch: false, // Added explicit isPerfectMatch false
-        });
-        props.buffer.setText('/clear');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('/clear'));
-        unmount();
-    });
-    it('should submit on Enter when an @-path is a perfect match', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'file.txt', value: 'file.txt' }],
-            activeSuggestionIndex: 0,
-            isPerfectMatch: true,
-            completionMode: CompletionMode.AT,
-        });
-        props.buffer.text = '@file.txt';
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            // Should submit directly
-            expect(props.onSubmit).toHaveBeenCalledWith('@file.txt');
-        });
-        unmount();
-    });
-    it('should NOT submit on Shift+Enter even if an @-path is a perfect match', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'file.txt', value: 'file.txt' }],
-            activeSuggestionIndex: 0,
-            isPerfectMatch: true,
-            completionMode: CompletionMode.AT,
-        });
-        props.buffer.text = '@file.txt';
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            // Simulate Shift+Enter using CSI u sequence
-            stdin.write('\x1b[13;2u');
-        });
-        // Should NOT submit, should call newline instead
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        expect(props.buffer.newline).toHaveBeenCalled();
-        unmount();
-    });
-    it('should auto-execute commands with autoExecute: true on Enter', async () => {
-        const aboutCommand = {
-            name: 'about',
-            kind: CommandKind.BUILT_IN,
-            description: 'About command',
-            action: vi.fn(),
-            autoExecute: true,
-        };
-        const suggestion = { label: 'about', value: 'about' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(aboutCommand),
-            getCompletedText: vi.fn().mockReturnValue('/about'),
-            slashCompletionRange: {
-                completionStart: 1,
-                completionEnd: 3, // "/ab" -> start at 1, end at 3
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: false,
-                leafCommand: null,
-            },
-        });
-        // User typed partial command
-        props.buffer.setText('/ab');
-        props.buffer.lines = ['/ab'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should submit the full command constructed from buffer + suggestion
-            expect(props.onSubmit).toHaveBeenCalledWith('/about');
-            // Should NOT handle autocomplete (which just fills text)
-            expect(mockCommandCompletion.handleAutocomplete).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete commands with autoExecute: false on Enter', async () => {
-        const shareCommand = {
-            name: 'share',
-            kind: CommandKind.BUILT_IN,
-            description: 'Share conversation to file',
-            action: vi.fn(),
-            autoExecute: false, // Explicitly set to false
-        };
-        const suggestion = { label: 'share', value: 'share' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(shareCommand),
-            getCompletedText: vi.fn().mockReturnValue('/share'),
-        });
-        props.buffer.setText('/sh');
-        props.buffer.lines = ['/sh'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete to allow adding file argument
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete on Tab, even for executable commands', async () => {
-        const executableCommand = {
-            name: 'about',
-            kind: CommandKind.BUILT_IN,
-            description: 'About info',
-            action: vi.fn(),
-            autoExecute: true,
-        };
-        const suggestion = { label: 'about', value: 'about' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(executableCommand),
-            getCompletedText: vi.fn().mockReturnValue('/about'),
-        });
-        props.buffer.setText('/ab');
-        props.buffer.lines = ['/ab'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t'); // Tab
-        });
-        await waitFor(() => {
-            // Tab always autocompletes, never executes
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should NOT autocomplete on Shift+Tab', async () => {
-        const suggestion = { label: 'about', value: 'about' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCompletedText: vi.fn().mockReturnValue('/about'),
-        });
-        props.buffer.setText('/ab');
-        props.buffer.lines = ['/ab'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x1b[Z'); // Shift+Tab
-        });
-        // We need to wait a bit to ensure handleAutocomplete was NOT called
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        expect(mockCommandCompletion.handleAutocomplete).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should autocomplete custom commands from .toml files on Enter', async () => {
-        const customCommand = {
-            name: 'find-capital',
-            kind: CommandKind.USER_FILE,
-            description: 'Find capital of a country',
-            action: vi.fn(),
-            // No autoExecute flag - custom commands default to undefined
-        };
-        const suggestion = { label: 'find-capital', value: 'find-capital' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(customCommand),
-            getCompletedText: vi.fn().mockReturnValue('/find-capital'),
-        });
-        props.buffer.setText('/find');
-        props.buffer.lines = ['/find'];
-        props.buffer.cursor = [0, 5];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete (not execute) since autoExecute is undefined
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should auto-execute argument completion when command has autoExecute: true', async () => {
-        // Simulates: /mcp auth <server> where user selects a server from completions
-        const authCommand = {
-            name: 'auth',
-            kind: CommandKind.BUILT_IN,
-            description: 'Authenticate with MCP server',
-            action: vi.fn(),
-            autoExecute: true,
-            completion: vi.fn().mockResolvedValue(['server1', 'server2']),
-        };
-        const suggestion = { label: 'server1', value: 'server1' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(authCommand),
-            getCompletedText: vi.fn().mockReturnValue('/mcp auth server1'),
-            slashCompletionRange: {
-                completionStart: 10,
-                completionEnd: 10,
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: true,
-                leafCommand: authCommand,
-            },
-        });
-        props.buffer.setText('/mcp auth ');
-        props.buffer.lines = ['/mcp auth '];
-        props.buffer.cursor = [0, 10];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should auto-execute with the completed command
-            expect(props.onSubmit).toHaveBeenCalledWith('/mcp auth server1');
-            expect(mockCommandCompletion.handleAutocomplete).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete argument completion when command has autoExecute: false', async () => {
-        // Simulates: /extensions enable <ext> where multi-arg completions should NOT auto-execute
-        const enableCommand = {
-            name: 'enable',
-            kind: CommandKind.BUILT_IN,
-            description: 'Enable an extension',
-            action: vi.fn(),
-            autoExecute: false,
-            completion: vi.fn().mockResolvedValue(['ext1 --scope user']),
-        };
-        const suggestion = {
-            label: 'ext1 --scope user',
-            value: 'ext1 --scope user',
-        };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(enableCommand),
-            getCompletedText: vi
-                .fn()
-                .mockReturnValue('/extensions enable ext1 --scope user'),
-            slashCompletionRange: {
-                completionStart: 19,
-                completionEnd: 19,
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: true,
-                leafCommand: enableCommand,
-            },
-        });
-        props.buffer.setText('/extensions enable ');
-        props.buffer.lines = ['/extensions enable '];
-        props.buffer.cursor = [0, 19];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete (not execute) to allow user to modify
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete command name even with autoExecute: true if command has completion function', async () => {
-        // Simulates: /chat resu -> should NOT auto-execute, should autocomplete to show arg completions
-        const resumeCommand = {
-            name: 'resume',
-            kind: CommandKind.BUILT_IN,
-            description: 'Resume a conversation',
-            action: vi.fn(),
-            autoExecute: true,
-            completion: vi.fn().mockResolvedValue(['chat1', 'chat2']),
-        };
-        const suggestion = { label: 'resume', value: 'resume' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(resumeCommand),
-            getCompletedText: vi.fn().mockReturnValue('/chat resume'),
-            slashCompletionRange: {
-                completionStart: 6,
-                completionEnd: 10,
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: false,
-                leafCommand: null,
-            },
-        });
-        props.buffer.setText('/chat resu');
-        props.buffer.lines = ['/chat resu'];
-        props.buffer.cursor = [0, 10];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete to allow selecting an argument, NOT auto-execute
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete an @-path on Enter without submitting', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'index.ts', value: 'index.ts' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('@src/components/');
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should add a newline on enter when the line ends with a backslash', async () => {
-        // This test simulates multi-line input, not submission
-        mockBuffer.text = 'first line\\';
-        mockBuffer.cursor = [0, 11];
-        mockBuffer.lines = ['first line\\'];
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(props.buffer.backspace).toHaveBeenCalled();
-            expect(props.buffer.newline).toHaveBeenCalled();
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should clear the buffer on Ctrl+C if it has text', async () => {
-        await act(async () => {
-            props.buffer.setText('some text to clear');
-        });
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x03'); // Ctrl+C character
-        });
-        await waitFor(() => {
-            expect(props.buffer.setText).toHaveBeenCalledWith('');
-            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should render correctly in plan mode', async () => {
-        props.approvalMode = ApprovalMode.PLAN;
-        const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-        await waitFor(() => {
-            const frame = stdout.lastFrameRaw();
-            // In plan mode it uses '>' but with success color.
-            // We check that it contains '>' and not '*' or '!'.
-            expect(frame).toContain('>');
-            expect(frame).not.toContain('*');
-            expect(frame).not.toContain('!');
-        });
-        unmount();
-    });
-    it('should NOT clear the buffer on Ctrl+C if it is empty', async () => {
-        props.buffer.text = '';
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x03'); // Ctrl+C character
-        });
-        await waitFor(() => {
-            expect(props.buffer.setText).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should call setBannerVisible(false) when clear screen key is pressed', async () => {
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x0C'); // Ctrl+L
-        });
-        await waitFor(() => {
-            expect(props.setBannerVisible).toHaveBeenCalledWith(false);
-        });
-        unmount();
-    });
-    describe('cursor-based completion trigger', () => {
-        it.each([
-            {
-                name: 'should trigger completion when cursor is after @ without spaces',
-                text: '@src/components',
-                cursor: [0, 15],
-                showSuggestions: true,
-            },
-            {
-                name: 'should trigger completion when cursor is after / without spaces',
-                text: '/memory',
-                cursor: [0, 7],
-                showSuggestions: true,
-            },
-            {
-                name: 'should NOT trigger completion when cursor is after space following @',
-                text: '@src/file.ts hello',
-                cursor: [0, 18],
-                showSuggestions: false,
-            },
-            {
-                name: 'should NOT trigger completion when cursor is after space following /',
-                text: '/memory list',
-                cursor: [0, 12],
-                showSuggestions: false,
-            },
-            {
-                name: 'should NOT trigger completion when cursor is not after @ or /',
-                text: 'hello world',
-                cursor: [0, 5],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle multiline text correctly',
-                text: 'first line\n/memory',
-                cursor: [1, 7],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle Unicode characters (emojis) correctly in paths',
-                text: '@src/file👍.txt',
-                cursor: [0, 14],
-                showSuggestions: true,
-            },
-            {
-                name: 'should handle Unicode characters with spaces after them',
-                text: '@src/file👍.txt hello',
-                cursor: [0, 20],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle escaped spaces in paths correctly',
-                text: '@src/my\\ file.txt',
-                cursor: [0, 16],
-                showSuggestions: true,
-            },
-            {
-                name: 'should NOT trigger completion after unescaped space following escaped space',
-                text: '@path/my\\ file.txt hello',
-                cursor: [0, 24],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle multiple escaped spaces in paths',
-                text: '@docs/my\\ long\\ file\\ name.md',
-                cursor: [0, 29],
-                showSuggestions: true,
-            },
-            {
-                name: 'should handle escaped spaces in slash commands',
-                text: '/memory\\ test',
-                cursor: [0, 13],
-                showSuggestions: true,
-            },
-            {
-                name: 'should handle Unicode characters with escaped spaces',
-                text: `@${path.join('files', 'emoji\\ 👍\\ test.txt')}`,
-                cursor: [0, 25],
-                showSuggestions: true,
-            },
-        ])('$name', async ({ text, cursor, showSuggestions }) => {
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.cursor = cursor;
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions,
-                suggestions: showSuggestions
-                    ? [{ label: 'suggestion', value: 'suggestion' }]
-                    : [],
-            });
-            const { unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenCalledWith({
-                    buffer: mockBuffer,
-                    cwd: path.join('test', 'project', 'src'),
-                    slashCommands: mockSlashCommands,
-                    commandContext: mockCommandContext,
-                    reverseSearchActive: false,
-                    shellModeActive: false,
-                    config: expect.any(Object),
-                    active: expect.anything(),
-                });
-            });
-            unmount();
-        });
-    });
-    describe('vim mode', () => {
-        it.each([
-            {
-                name: 'should not call buffer.handleInput when vim handles input',
-                vimHandled: true,
-                expectBufferHandleInput: false,
-            },
-            {
-                name: 'should call buffer.handleInput when vim does not handle input',
-                vimHandled: false,
-                expectBufferHandleInput: true,
-            },
-            {
-                name: 'should call handleInput when vim mode is disabled',
-                vimHandled: false,
-                expectBufferHandleInput: true,
-            },
-        ])('$name', async ({ vimHandled, expectBufferHandleInput }) => {
-            props.vimHandleInput = vi.fn().mockReturnValue(vimHandled);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => stdin.write('i'));
-            await waitFor(() => {
-                expect(props.vimHandleInput).toHaveBeenCalled();
-                if (expectBufferHandleInput) {
-                    expect(mockBuffer.handleInput).toHaveBeenCalled();
-                }
-                else {
-                    expect(mockBuffer.handleInput).not.toHaveBeenCalled();
-                }
-            });
-            unmount();
-        });
-    });
-    describe('unfocused paste', () => {
-        it('should handle bracketed paste when not focused', async () => {
-            props.focus = false;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B[200~pasted text\x1B[201~');
-            });
-            await waitFor(() => {
-                expect(mockBuffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
-                    name: 'paste',
-                    sequence: 'pasted text',
-                }));
-            });
-            unmount();
-        });
-        it('should ignore regular keypresses when not focused', async () => {
-            props.focus = false;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('a');
-            });
-            await waitFor(() => { });
-            expect(mockBuffer.handleInput).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('Highlighting and Cursor Display', () => {
-        describe('single-line scenarios', () => {
-            it.each([
-                {
-                    name: 'mid-word',
-                    text: 'hello world',
-                    visualCursor: [0, 3],
-                },
-                {
-                    name: 'at the beginning of the line',
-                    text: 'hello',
-                    visualCursor: [0, 0],
-                },
-                {
-                    name: 'at the end of the line',
-                    text: 'hello',
-                    visualCursor: [0, 5],
-                },
-                {
-                    name: 'on a highlighted token',
-                    text: 'run @path/to/file',
-                    visualCursor: [0, 9],
-                },
-                {
-                    name: 'for multi-byte unicode characters',
-                    text: 'hello 👍 world',
-                    visualCursor: [0, 6],
-                },
-                {
-                    name: 'after multi-byte unicode characters',
-                    text: '👍A',
-                    visualCursor: [0, 1],
-                },
-                {
-                    name: 'at the end of a line with unicode characters',
-                    text: 'hello 👍',
-                    visualCursor: [0, 8],
-                },
-                {
-                    name: 'at the end of a short line with unicode characters',
-                    text: '👍',
-                    visualCursor: [0, 1],
-                },
-                {
-                    name: 'on an empty line',
-                    text: '',
-                    visualCursor: [0, 0],
-                },
-                {
-                    name: 'on a space between words',
-                    text: 'hello world',
-                    visualCursor: [0, 5],
-                },
-            ])('should display cursor correctly $name', async ({ text, visualCursor }) => {
-                mockBuffer.text = text;
-                mockBuffer.lines = [text];
-                mockBuffer.allVisualLines = [text];
-                mockBuffer.viewportVisualLines = [text];
-                mockBuffer.visualCursor = visualCursor;
-                props.config.getUseBackgroundColor = () => false;
-                const renderResult = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-                await renderResult.waitUntilReady();
-                await expect(renderResult).toMatchSvgSnapshot();
-                renderResult.unmount();
-            });
-        });
-        describe('multi-line scenarios', () => {
-            it.each([
-                {
-                    name: 'in the middle of a line',
-                    text: 'first line\nsecond line\nthird line',
-                    visualCursor: [1, 3],
-                    visualToLogicalMap: [
-                        [0, 0],
-                        [1, 0],
-                        [2, 0],
-                    ],
-                },
-                {
-                    name: 'at the beginning of a line',
-                    text: 'first line\nsecond line',
-                    visualCursor: [1, 0],
-                    visualToLogicalMap: [
-                        [0, 0],
-                        [1, 0],
-                    ],
-                },
-                {
-                    name: 'at the end of a line',
-                    text: 'first line\nsecond line',
-                    visualCursor: [0, 10],
-                    visualToLogicalMap: [
-                        [0, 0],
-                        [1, 0],
-                    ],
-                },
-            ])('should display cursor correctly $name in a multiline block', async ({ text, visualCursor, visualToLogicalMap }) => {
-                mockBuffer.text = text;
-                mockBuffer.lines = text.split('\n');
-                mockBuffer.allVisualLines = text.split('\n');
-                mockBuffer.viewportVisualLines = text.split('\n');
-                mockBuffer.visualCursor = visualCursor;
-                mockBuffer.visualToLogicalMap = visualToLogicalMap;
-                props.config.getUseBackgroundColor = () => false;
-                const renderResult = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-                await renderResult.waitUntilReady();
-                await expect(renderResult).toMatchSvgSnapshot();
-                renderResult.unmount();
-            });
-            it('should display cursor on a blank line in a multiline block', async () => {
-                const text = 'first line\n\nthird line';
-                mockBuffer.text = text;
-                mockBuffer.lines = text.split('\n');
-                mockBuffer.allVisualLines = text.split('\n');
-                mockBuffer.viewportVisualLines = text.split('\n');
-                mockBuffer.visualCursor = [1, 0]; // cursor on the blank line
-                mockBuffer.visualToLogicalMap = [
-                    [0, 0],
-                    [1, 0],
-                    [2, 0],
-                ];
-                props.config.getUseBackgroundColor = () => false;
-                const renderResult = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-                await renderResult.waitUntilReady();
-                await expect(renderResult).toMatchSvgSnapshot();
-                renderResult.unmount();
-            });
-        });
-    });
-    describe('scrolling large inputs', () => {
-        it('should correctly render scrolling down and up for large inputs', async () => {
-            const lines = Array.from({ length: 50 }).map((_, i) => `testline ${i}`);
-            // Since we need to test how the React component tree responds to TextBuffer state changes,
-            // we must provide a fake TextBuffer implementation that triggers re-renders like the real one.
-            const TestWrapper = () => {
-                const [bufferState, setBufferState] = useState({
-                    text: lines.join('\n'),
-                    lines,
-                    allVisualLines: lines,
-                    viewportVisualLines: lines.slice(0, 10),
-                    visualToLogicalMap: lines.map((_, i) => [i, 0]),
-                    visualCursor: [0, 0],
-                    visualScrollRow: 0,
-                    viewportHeight: 10,
-                });
-                const fakeBuffer = {
-                    ...mockBuffer,
-                    ...bufferState,
-                    handleInput: vi.fn().mockImplementation((key) => {
-                        let newRow = bufferState.visualCursor[0];
-                        let newScroll = bufferState.visualScrollRow;
-                        if (key.name === 'down') {
-                            newRow = Math.min(49, newRow + 1);
-                            if (newRow >= newScroll + 10)
-                                newScroll++;
-                        }
-                        else if (key.name === 'up') {
-                            newRow = Math.max(0, newRow - 1);
-                            if (newRow < newScroll)
-                                newScroll--;
-                        }
-                        setBufferState({
-                            ...bufferState,
-                            visualCursor: [newRow, 0],
-                            visualScrollRow: newScroll,
-                            viewportVisualLines: lines.slice(newScroll, newScroll + 10),
-                        });
-                        return true;
-                    }),
-                };
-                const inputState = {
-                    buffer: fakeBuffer,
-                    userMessages: [],
-                    shellModeActive: false,
-                    showEscapePrompt: false,
-                    copyModeEnabled: false,
-                    inputWidth: 80,
-                    suggestionsWidth: 80,
-                };
-                return (_jsx(InputContext.Provider, { value: inputState, children: _jsx(InputPrompt, { ...props }) }));
-            };
-            const { stdout, unmount, stdin } = await renderWithProviders(_jsx(TestWrapper, {}), {
-                uiActions,
-            });
-            // Verify initial render
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('testline 0');
-                expect(stdout.lastFrame()).not.toContain('testline 49');
-            });
-            // Move cursor to bottom
-            for (let i = 0; i < 49; i++) {
-                act(() => {
-                    stdin.write('\x1b[B'); // Arrow Down
-                });
-            }
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('testline 49');
-                expect(stdout.lastFrame()).not.toContain('testline 0');
-            });
-            // Move cursor back to top
-            for (let i = 0; i < 49; i++) {
-                act(() => {
-                    stdin.write('\x1b[A'); // Arrow Up
-                });
-            }
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('testline 0');
-                expect(stdout.lastFrame()).not.toContain('testline 49');
-            });
-            unmount();
-        });
-    });
-    describe('multiline rendering', () => {
-        it('should correctly render multiline input including blank lines', async () => {
-            const text = 'hello\n\nworld';
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.allVisualLines = text.split('\n');
-            mockBuffer.viewportVisualLines = text.split('\n');
-            mockBuffer.allVisualLines = text.split('\n');
-            mockBuffer.visualCursor = [2, 5]; // cursor at the end of "world"
-            // Provide a visual-to-logical mapping for each visual line
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-                [2, 0],
-            ];
-            props.config.getUseBackgroundColor = () => false;
-            const renderResult = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await renderResult.waitUntilReady();
-            await expect(renderResult).toMatchSvgSnapshot();
-            renderResult.unmount();
-        });
-    });
-    describe('multiline paste', () => {
-        it.each([
-            {
-                description: 'with \n newlines',
-                pastedText: 'This \n is \n a \n multiline \n paste.',
-            },
-            {
-                description: 'with extra slashes before \n newlines',
-                pastedText: 'This \\\n is \\\n a \\\n multiline \\\n paste.',
-            },
-            {
-                description: 'with \r\n newlines',
-                pastedText: 'This\r\nis\r\na\r\nmultiline\r\npaste.',
-            },
-        ])('should handle multiline paste $description', async ({ pastedText }) => {
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            // Simulate a bracketed paste event from the terminal
-            await act(async () => {
-                stdin.write(`\x1b[200~${pastedText}\x1b[201~`);
-            });
-            await waitFor(() => {
-                // Verify that the buffer's handleInput was called once with the full text
-                expect(props.buffer.handleInput).toHaveBeenCalledTimes(1);
-                expect(props.buffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
-                    name: 'paste',
-                    sequence: pastedText,
-                }));
-            });
-            unmount();
-        });
-    });
-    describe('large paste placeholder', () => {
-        it('should handle large clipboard paste (lines > 5) by calling buffer.insert', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const largeText = '1\n2\n3\n4\n5\n6';
-            vi.mocked(clipboardy.read).mockResolvedValue(largeText);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(mockBuffer.insert).toHaveBeenCalledWith(largeText, expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should handle large clipboard paste (chars > 500) by calling buffer.insert', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const largeText = 'a'.repeat(501);
-            vi.mocked(clipboardy.read).mockResolvedValue(largeText);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(mockBuffer.insert).toHaveBeenCalledWith(largeText, expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should handle normal clipboard paste by calling buffer.insert', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const smallText = 'hello world';
-            vi.mocked(clipboardy.read).mockResolvedValue(smallText);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(mockBuffer.insert).toHaveBeenCalledWith(smallText, expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should replace placeholder with actual content on submit', async () => {
-            // Setup buffer to have the placeholder
-            const largeText = '1\n2\n3\n4\n5\n6';
-            const id = '[Pasted Text: 6 lines]';
-            mockBuffer.text = `Check this: ${id}`;
-            mockBuffer.pastedContent = { [id]: largeText };
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\r'); // Enter
-            });
-            await waitFor(() => {
-                expect(props.onSubmit).toHaveBeenCalledWith(`Check this: ${largeText}`);
-            });
-            unmount();
-        });
-    });
-    describe('paste auto-submission protection', () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-            mockedUseKittyKeyboardProtocol.mockReturnValue({
-                enabled: false,
-                checking: false,
-            });
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-            vi.restoreAllMocks();
-        });
-        it('should prevent auto-submission immediately after an unsafe paste', async () => {
-            // isTerminalPasteTrusted will be false due to beforeEach setup.
-            props.buffer.text = 'some command';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate a paste operation (this should set the paste protection)
-            await act(async () => {
-                stdin.write(`\x1b[200~pasted content\x1b[201~`);
-            });
-            // Simulate an Enter key press immediately after paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Verify that onSubmit was NOT called due to recent paste protection
-            expect(props.onSubmit).not.toHaveBeenCalled();
-            // It should call newline() instead
-            expect(props.buffer.newline).toHaveBeenCalled();
-            unmount();
-        });
-        it('should prevent perfect match auto-submission immediately after an unsafe paste', async () => {
-            // isTerminalPasteTrusted will be false due to beforeEach setup.
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                isPerfectMatch: true,
-                completionMode: CompletionMode.AT,
-            });
-            props.buffer.text = '@file.txt';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            // Simulate an unsafe paste of a perfect match
-            await act(async () => {
-                stdin.write(`\x1b[200~@file.txt\x1b[201~`);
-            });
-            // Simulate an Enter key press immediately after paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            // Verify that onSubmit was NOT called due to recent paste protection
-            expect(props.onSubmit).not.toHaveBeenCalled();
-            // It should call newline() instead
-            expect(props.buffer.newline).toHaveBeenCalled();
-            unmount();
-        });
-        it('should allow submission after unsafe paste protection timeout', async () => {
-            // isTerminalPasteTrusted will be false due to beforeEach setup.
-            props.buffer.text = 'pasted text';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate a paste operation (this sets the protection)
-            await act(async () => {
-                stdin.write('\x1b[200~pasted text\x1b[201~');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Advance timers past the protection timeout
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(50);
-            });
-            // Now Enter should work normally
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            expect(props.onSubmit).toHaveBeenCalledWith('pasted text');
-            expect(props.buffer.newline).not.toHaveBeenCalled();
-            unmount();
-        });
-        it.each([
-            {
-                name: 'kitty',
-                setup: () => mockedUseKittyKeyboardProtocol.mockReturnValue({
-                    enabled: true,
-                    checking: false,
-                }),
-            },
-        ])('should allow immediate submission for a trusted paste ($name)', async ({ setup }) => {
-            setup();
-            props.buffer.text = 'pasted command';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate a paste operation
-            await act(async () => {
-                stdin.write('\x1b[200~some pasted stuff\x1b[201~');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate an Enter key press immediately after paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Verify that onSubmit was called
-            expect(props.onSubmit).toHaveBeenCalledWith('pasted command');
-            unmount();
-        });
-        it('should not interfere with normal Enter key submission when no recent paste', async () => {
-            // Set up buffer with text before rendering to ensure submission works
-            props.buffer.text = 'normal command';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Press Enter without any recent paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Verify that onSubmit was called normally
-            expect(props.onSubmit).toHaveBeenCalledWith('normal command');
-            unmount();
-        });
-    });
-    describe('enhanced input UX - keyboard shortcuts', () => {
-        beforeEach(() => vi.useFakeTimers());
-        afterEach(() => vi.useRealTimers());
-        it('should clear buffer on Ctrl-C', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('text to clear');
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x03');
-                vi.advanceTimersByTime(100);
-                expect(props.buffer.setText).toHaveBeenCalledWith('');
-                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should submit /rewind on double ESC when buffer is empty', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('');
-            vi.mocked(props.buffer.setText).mockClear();
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiState: {
-                    history: [{ id: 1, type: 'user', text: 'test' }],
-                },
-            });
-            await act(async () => {
-                stdin.write('\x1B\x1B');
-                vi.advanceTimersByTime(100);
-            });
-            await waitFor(() => {
-                expect(props.onSubmit).toHaveBeenCalledWith('/rewind');
-            });
-            unmount();
-        });
-        it('should clear the buffer on esc esc if it has text', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('some text');
-            vi.mocked(props.buffer.setText).mockClear();
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B\x1B');
-                vi.advanceTimersByTime(100);
-                expect(props.buffer.setText).toHaveBeenCalledWith('');
-                expect(props.onSubmit).not.toHaveBeenCalledWith('/rewind');
-            });
-            unmount();
-        });
-        it('should reset escape state on any non-ESC key', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('some text');
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B');
-                await waitFor(() => {
-                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
-                });
-            });
-            await act(async () => {
-                stdin.write('a');
-                await waitFor(() => {
-                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
-                });
-            });
-            unmount();
-        });
-        it('should handle ESC in shell mode by disabling shell mode', async () => {
-            props.shellModeActive = true;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B');
-                vi.advanceTimersByTime(100);
-                expect(props.setShellModeActive).toHaveBeenCalledWith(false);
-            });
-            unmount();
-        });
-        it('should not propagate ESC to global cancellation handler when shell mode is active (responding)', async () => {
-            props.shellModeActive = true;
-            props.streamingState = StreamingState.Responding;
-            const onGlobalEscape = vi.fn();
-            const { stdin, unmount } = await renderWithProviders(_jsxs(_Fragment, { children: [_jsx(GlobalEscapeHandler, { onEscape: onGlobalEscape }), _jsx(TestInputPrompt, { ...props })] }));
-            await act(async () => {
-                stdin.write('\x1B');
-                vi.advanceTimersByTime(100);
-            });
-            await waitFor(() => {
-                expect(props.setShellModeActive).toHaveBeenCalledWith(false);
-            });
-            expect(onGlobalEscape).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should allow ESC to reach global cancellation handler when responding and no overlay is active', async () => {
-            props.shellModeActive = false;
-            props.streamingState = StreamingState.Responding;
-            const onGlobalEscape = vi.fn();
-            const { stdin, unmount } = await renderWithProviders(_jsxs(_Fragment, { children: [_jsx(GlobalEscapeHandler, { onEscape: onGlobalEscape }), _jsx(TestInputPrompt, { ...props })] }));
-            await act(async () => {
-                stdin.write('\x1B');
-                vi.advanceTimersByTime(100);
-            });
-            await waitFor(() => {
-                expect(onGlobalEscape).toHaveBeenCalledTimes(1);
-            });
-            expect(props.setShellModeActive).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should handle ESC when completion suggestions are showing', async () => {
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions: true,
-                suggestions: [{ label: 'suggestion', value: 'suggestion' }],
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B');
-                vi.advanceTimersByTime(100);
-                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should not call onEscapePromptChange when not provided', async () => {
-            props.onEscapePromptChange = undefined;
-            props.buffer.setText('some text');
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            await act(async () => {
-                stdin.write('\x1B');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            unmount();
-        });
-        it('should not interfere with existing keyboard shortcuts', async () => {
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x0C');
-            });
-            await waitFor(() => expect(props.onClearScreen).toHaveBeenCalled());
-            await act(async () => {
-                stdin.write('\x01');
-            });
-            await waitFor(() => expect(props.buffer.move).toHaveBeenCalledWith('home'));
-            unmount();
-        });
-    });
-    describe('reverse search', () => {
-        beforeEach(async () => {
-            props.shellModeActive = true;
-            vi.mocked(useShellHistory).mockReturnValue({
-                history: ['echo hello', 'echo world', 'ls'],
-                getPreviousCommand: vi.fn(),
-                getNextCommand: vi.fn(),
-                addCommandToHistory: vi.fn(),
-                resetHistoryPosition: vi.fn(),
-            });
-        });
-        it('invokes reverse search on Ctrl+R', async () => {
-            // Mock the reverse search completion to return suggestions
-            mockedUseReverseSearchCompletion.mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [
-                    { label: 'echo hello', value: 'echo hello' },
-                    { label: 'echo world', value: 'echo world' },
-                    { label: 'ls', value: 'ls' },
-                ],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-            });
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            // Trigger reverse search with Ctrl+R
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                const frame = stdout.lastFrameRaw();
-                expect(frame).toContain('(r:)');
-                expect(frame).toContain('echo hello');
-                expect(frame).toContain('echo world');
-                expect(frame).toContain('ls');
-            });
-            unmount();
-        });
-        it.each([
-            { name: 'standard', escapeSequence: '\x1B' },
-            { name: 'kitty', escapeSequence: '\u001b[27u' },
-        ])('resets reverse search state on Escape ($name)', async ({ escapeSequence }) => {
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            // Wait for reverse search to be active
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            await act(async () => {
-                stdin.write(escapeSequence);
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('(r:)');
-                expect(stdout.lastFrame()).not.toContain('echo hello');
-            });
-            unmount();
-        });
-        it('completes the highlighted entry on Tab and exits reverse-search', async () => {
-            // Mock the reverse search completion
-            const mockHandleAutocomplete = vi.fn(() => {
-                props.buffer.setText('echo hello');
-            });
-            mockedUseReverseSearchCompletion.mockImplementation((buffer, shellHistory, reverseSearchActive) => ({
-                ...mockReverseSearchCompletion,
-                suggestions: reverseSearchActive
-                    ? [
-                        { label: 'echo hello', value: 'echo hello' },
-                        { label: 'echo world', value: 'echo world' },
-                        { label: 'ls', value: 'ls' },
-                    ]
-                    : [],
-                showSuggestions: reverseSearchActive,
-                activeSuggestionIndex: reverseSearchActive ? 0 : -1,
-                handleAutocomplete: mockHandleAutocomplete,
-            }));
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            // Enter reverse search mode with Ctrl+R
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            // Verify reverse search is active
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            // Press Tab to complete the highlighted entry
-            await act(async () => {
-                stdin.write('\t');
-            });
-            await waitFor(() => {
-                expect(mockHandleAutocomplete).toHaveBeenCalledWith(0);
-                expect(props.buffer.setText).toHaveBeenCalledWith('echo hello');
-            });
-            unmount();
-        }, 15000);
-        it('should NOT autocomplete on Shift+Tab in reverse search', async () => {
-            const mockHandleAutocomplete = vi.fn();
-            mockedUseReverseSearchCompletion.mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label: 'echo hello', value: 'echo hello' }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                handleAutocomplete: mockHandleAutocomplete,
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\x12'); // Ctrl+R
-            });
-            await act(async () => {
-                stdin.write('\x1b[Z'); // Shift+Tab
-            });
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            expect(mockHandleAutocomplete).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('submits the highlighted entry on Enter and exits reverse-search', async () => {
-            // Mock the reverse search completion to return suggestions
-            mockedUseReverseSearchCompletion.mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [
-                    { label: 'echo hello', value: 'echo hello' },
-                    { label: 'echo world', value: 'echo world' },
-                    { label: 'ls', value: 'ls' },
-                ],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-            });
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('(r:)');
-            });
-            expect(props.onSubmit).toHaveBeenCalledWith('echo hello');
-            unmount();
-        });
-        it('should restore text and cursor position after reverse search"', async () => {
-            const initialText = 'initial text';
-            const initialCursor = [0, 3];
-            props.buffer.setText(initialText);
-            props.buffer.cursor = initialCursor;
-            // Mock the reverse search completion to be active and then reset
-            mockedUseReverseSearchCompletion.mockImplementation((buffer, shellHistory, reverseSearchActiveFromInputPrompt) => ({
-                ...mockReverseSearchCompletion,
-                suggestions: reverseSearchActiveFromInputPrompt
-                    ? [{ label: 'history item', value: 'history item' }]
-                    : [],
-                showSuggestions: reverseSearchActiveFromInputPrompt,
-            }));
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            // reverse search with Ctrl+R
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            // Press kitty escape key
-            await act(async () => {
-                stdin.write('\u001b[27u');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('(r:)');
-                expect(props.buffer.text).toBe(initialText);
-                expect(props.buffer.cursor).toEqual(initialCursor);
-            });
-            unmount();
-        });
-    });
-    describe('Ctrl+E keyboard shortcut', () => {
-        it('should move cursor to end of current line in multiline input', async () => {
-            props.buffer.text = 'line 1\nline 2\nline 3';
-            props.buffer.cursor = [1, 2];
-            props.buffer.lines = ['line 1', 'line 2', 'line 3'];
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x05'); // Ctrl+E
-            });
-            await waitFor(() => {
-                expect(props.buffer.move).toHaveBeenCalledWith('end');
-            });
-            expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should move cursor to end of current line for single line input', async () => {
-            props.buffer.text = 'single line text';
-            props.buffer.cursor = [0, 5];
-            props.buffer.lines = ['single line text'];
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x05'); // Ctrl+E
-            });
-            await waitFor(() => {
-                expect(props.buffer.move).toHaveBeenCalledWith('end');
-            });
-            expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('command search (Ctrl+R when not in shell)', () => {
-        it('enters command search on Ctrl+R and shows suggestions', async () => {
-            props.shellModeActive = false;
-            vi.mocked(useReverseSearchCompletion).mockImplementation((buffer, data, isActive) => ({
-                ...mockReverseSearchCompletion,
-                suggestions: isActive
-                    ? [
-                        { label: 'git commit -m "msg"', value: 'git commit -m "msg"' },
-                        { label: 'git push', value: 'git push' },
-                    ]
-                    : [],
-                showSuggestions: !!isActive,
-                activeSuggestionIndex: isActive ? 0 : -1,
-            }));
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12'); // Ctrl+R
-            });
-            await waitFor(() => {
-                const frame = stdout.lastFrameRaw() ?? '';
-                expect(frame).toContain('(r:)');
-                expect(frame).toContain('git commit');
-                expect(frame).toContain('git push');
-            });
-            unmount();
-        });
-        it('expands and collapses long suggestion via Right/Left arrows', async () => {
-            props.shellModeActive = false;
-            const longValue = 'l'.repeat(200);
-            vi.mocked(useReverseSearchCompletion).mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label: longValue, value: longValue, matchedIndex: 0 }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                visibleStartIndex: 0,
-                isLoadingSuggestions: false,
-            });
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(clean(stdout.lastFrame())).toContain('→');
-            });
-            await act(async () => {
-                stdin.write('\u001B[C');
-            });
-            await waitFor(() => {
-                expect(clean(stdout.lastFrame())).toContain('←');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-expanded-match');
-            await act(async () => {
-                stdin.write('\u001B[D');
-            });
-            await waitFor(() => {
-                expect(clean(stdout.lastFrame())).toContain('→');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-collapsed-match');
-            unmount();
-        });
-        it('renders match window and expanded view (snapshots)', async () => {
-            props.shellModeActive = false;
-            props.buffer.setText('commit');
-            const label = 'git commit -m "feat: add search" in src/app';
-            const matchedIndex = label.indexOf('commit');
-            vi.mocked(useReverseSearchCompletion).mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label, value: label, matchedIndex }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                visibleStartIndex: 0,
-                isLoadingSuggestions: false,
-            });
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-collapsed-match');
-            await act(async () => {
-                stdin.write('\u001B[C');
-            });
-            await waitFor(() => {
-                // Just wait for any update to ensure it is stable.
-                // We could also wait for specific text if we knew it.
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-expanded-match');
-            unmount();
-        });
-        it('does not show expand/collapse indicator for short suggestions', async () => {
-            props.shellModeActive = false;
-            const shortValue = 'echo hello';
-            vi.mocked(useReverseSearchCompletion).mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label: shortValue, value: shortValue }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                visibleStartIndex: 0,
-                isLoadingSuggestions: false,
-            });
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                const frame = clean(stdout.lastFrame());
-                // Ensure it rendered the search mode
-                expect(frame).toContain('(r:)');
-                expect(frame).not.toContain('→');
-                expect(frame).not.toContain('←');
-            });
-            unmount();
-        });
-        it('ensures Ctrl+R search results are prioritized newest-to-oldest by reversing userMessages', async () => {
-            props.shellModeActive = false;
-            props.userMessages = ['oldest', 'middle', 'newest'];
-            await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            const calls = vi.mocked(useReverseSearchCompletion).mock.calls;
-            const commandSearchCall = calls.find((call) => call[1] === props.userMessages ||
-                (Array.isArray(call[1]) && call[1][0] === 'newest'));
-            expect(commandSearchCall).toBeDefined();
-            expect(commandSearchCall[1]).toEqual(['newest', 'middle', 'oldest']);
-        });
-    });
-    describe('Tab clean UI toggle', () => {
-        it.each([
-            {
-                name: 'should toggle clean UI details on double-Tab when no suggestions or ghost text',
-                showSuggestions: false,
-                ghostText: '',
-                suggestions: [],
-                expectedUiToggle: true,
-            },
-            {
-                name: 'should accept ghost text and NOT toggle clean UI details on Tab',
-                showSuggestions: false,
-                ghostText: 'ghost text',
-                suggestions: [],
-                expectedUiToggle: false,
-                expectedAcceptCall: true,
-            },
-            {
-                name: 'should NOT toggle clean UI details on Tab when suggestions are present',
-                showSuggestions: true,
-                ghostText: '',
-                suggestions: [{ label: 'test', value: 'test' }],
-                expectedUiToggle: false,
-            },
-        ])('$name', async ({ showSuggestions, ghostText, suggestions, expectedUiToggle, expectedAcceptCall, }) => {
-            const mockAccept = vi.fn();
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions,
-                suggestions,
-                promptCompletion: {
-                    text: ghostText,
-                    accept: mockAccept,
-                    clear: vi.fn(),
-                    isLoading: false,
-                    isActive: ghostText !== '',
-                    markSelected: vi.fn(),
-                },
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-                uiState: {},
-            });
-            await act(async () => {
-                stdin.write('\t');
-                if (expectedUiToggle) {
-                    stdin.write('\t');
-                }
-            });
-            await waitFor(() => {
-                if (expectedUiToggle) {
-                    expect(uiActions.toggleCleanUiDetailsVisible).toHaveBeenCalled();
-                }
-                else {
-                    expect(uiActions.toggleCleanUiDetailsVisible).not.toHaveBeenCalled();
-                }
-                if (expectedAcceptCall) {
-                    expect(mockAccept).toHaveBeenCalled();
-                }
-            });
-            unmount();
-        });
-        it('should NOT accept ghost text on Shift+Tab', async () => {
-            const mockAccept = vi.fn();
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions: false,
-                suggestions: [],
-                promptCompletion: {
-                    text: 'ghost text',
-                    accept: mockAccept,
-                    clear: vi.fn(),
-                    isLoading: false,
-                    isActive: true,
-                    markSelected: vi.fn(),
-                },
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\x1b[Z'); // Shift+Tab
-            });
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            expect(mockAccept).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should not reveal clean UI details on Shift+Tab when hidden', async () => {
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions: false,
-                suggestions: [],
-                promptCompletion: {
-                    text: '',
-                    accept: vi.fn(),
-                    clear: vi.fn(),
-                    isLoading: false,
-                    isActive: false,
-                    markSelected: vi.fn(),
-                },
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-                uiState: { activePtyId: 1, cleanUiDetailsVisible: false },
-            });
-            await act(async () => {
-                stdin.write('\x1b[Z');
-            });
-            await waitFor(() => {
-                expect(uiActions.revealCleanUiDetailsTemporarily).not.toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should toggle clean UI details on double-Tab by default', async () => {
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions: false,
-                suggestions: [],
-                promptCompletion: {
-                    text: '',
-                    accept: vi.fn(),
-                    clear: vi.fn(),
-                    isLoading: false,
-                    isActive: false,
-                    markSelected: vi.fn(),
-                },
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-                uiState: {},
-            });
-            await act(async () => {
-                stdin.write('\t');
-                stdin.write('\t');
-            });
-            await waitFor(() => {
-                expect(uiActions.toggleCleanUiDetailsVisible).toHaveBeenCalled();
-            });
-            unmount();
-        });
-    });
-    describe('mouse interaction', () => {
-        it.each([
-            {
-                name: 'first line, first char',
-                relX: 0,
-                relY: 0,
-                mouseCol: 4,
-                mouseRow: 2,
-            },
-            {
-                name: 'first line, middle char',
-                relX: 6,
-                relY: 0,
-                mouseCol: 10,
-                mouseRow: 2,
-            },
-            {
-                name: 'second line, first char',
-                relX: 0,
-                relY: 1,
-                mouseCol: 4,
-                mouseRow: 3,
-            },
-            {
-                name: 'second line, end char',
-                relX: 5,
-                relY: 1,
-                mouseCol: 9,
-                mouseRow: 3,
-            },
-        ])('should move cursor on mouse click - $name', async ({ relX, relY, mouseCol, mouseRow }) => {
-            props.buffer.text = 'hello world\nsecond line';
-            props.buffer.lines = ['hello world', 'second line'];
-            props.buffer.allVisualLines = ['hello world', 'second line'];
-            props.buffer.viewportVisualLines = ['hello world', 'second line'];
-            props.buffer.viewportHeight = 10;
-            props.buffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-            ];
-            props.buffer.visualCursor = [0, 11];
-            props.buffer.visualScrollRow = 0;
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { mouseEventsEnabled: true, uiActions });
-            // Wait for initial render
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello world');
-            });
-            // Simulate left mouse press at calculated coordinates.
-            // Without left border: inner box is at x=3, y=1 based on padding(1)+prompt(2) and border-top(1).
-            await act(async () => {
-                stdin.write(`\x1b[<0;${mouseCol};${mouseRow}M`);
-            });
-            await waitFor(() => {
-                expect(props.buffer.moveToVisualPosition).toHaveBeenCalledWith(relY, relX);
-            });
-            unmount();
-        });
-        it('should unfocus embedded shell on click', async () => {
-            props.buffer.setText('hello');
-            props.isEmbeddedShellFocused = true;
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { mouseEventsEnabled: true, uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello');
-            });
-            await act(async () => {
-                // Click somewhere in the prompt
-                stdin.write(`\x1b[<0;5;2M`);
-            });
-            await waitFor(() => {
-                expect(mockSetEmbeddedShellFocused).toHaveBeenCalledWith(false);
-            });
-            unmount();
-        });
-        it('should toggle paste expansion on double-click', async () => {
-            vi.spyOn(Date, 'now').mockReturnValue(1000);
-            const id = '[Pasted Text: 10 lines]';
-            const largeText = 'line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10';
-            const togglePasteExpansion = vi.fn();
-            const baseProps = props;
-            const TestWrapper = () => {
-                const [isExpanded, setIsExpanded] = useState(false);
-                const currentLines = isExpanded ? largeText.split('\n') : [id];
-                const currentText = isExpanded ? largeText : id;
-                const buffer = {
-                    ...baseProps.buffer,
-                    text: currentText,
-                    lines: currentLines,
-                    viewportVisualLines: currentLines,
-                    allVisualLines: currentLines,
-                    viewportHeight: 10,
-                    pastedContent: { [id]: largeText },
-                    transformationsByLine: isExpanded
-                        ? currentLines.map(() => [])
-                        : [
-                            [
-                                {
-                                    logStart: 0,
-                                    logEnd: id.length,
-                                    logicalText: id,
-                                    collapsedText: id,
-                                    type: 'paste',
-                                    id,
-                                },
-                            ],
-                        ],
-                    visualScrollRow: 0,
-                    visualToLogicalMap: currentLines.map((_, i) => [i, 0]),
-                    visualToTransformedMap: currentLines.map(() => 0),
-                    getLogicalPositionFromVisual: vi.fn().mockReturnValue({
-                        row: 0,
-                        col: 2,
-                    }),
-                    togglePasteExpansion: vi.fn().mockImplementation((...args) => {
-                        togglePasteExpansion(...args);
-                        setIsExpanded((expanded) => !expanded);
-                    }),
-                    getExpandedPasteAtLine: vi
-                        .fn()
-                        .mockReturnValue(isExpanded ? id : null),
-                };
-                return _jsx(TestInputPrompt, { ...baseProps, buffer: buffer });
-            };
-            const { stdout, unmount, simulateClick } = await renderWithProviders(_jsx(TestWrapper, {}), {
-                mouseEventsEnabled: true,
-                config: makeFakeConfig({ useAlternateBuffer: true }),
-                settings: createMockSettings({ ui: { useAlternateBuffer: true } }),
-                uiActions,
-            });
-            // 1. Verify initial placeholder
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toMatchSnapshot();
-            });
-            // Simulate double-click to expand
-            await simulateClick(5, 2);
-            await simulateClick(5, 2);
-            // 2. Verify expanded content is visible
-            await waitFor(() => {
-                expect(togglePasteExpansion).toHaveBeenCalledWith(id, 0, 2);
-                expect(stdout.lastFrame()).toContain('line10');
-            });
-            // Simulate double-click to collapse
-            await simulateClick(5, 2);
-            await simulateClick(5, 2);
-            // 3. Verify placeholder is restored
-            await waitFor(() => {
-                expect(togglePasteExpansion).toHaveBeenCalledTimes(2);
-                expect(stdout.lastFrame()).toContain(id);
-                expect(stdout.lastFrame()).toMatchSnapshot();
-            });
-            unmount();
-        });
-        it('should collapse expanded paste on double-click after the end of the line', async () => {
-            const id = '[Pasted Text: 10 lines]';
-            const largeText = 'line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10';
-            const baseProps = props;
-            const TestWrapper = () => {
-                const [isExpanded, setIsExpanded] = useState(true); // Start expanded
-                const currentLines = isExpanded ? largeText.split('\n') : [id];
-                const currentText = isExpanded ? largeText : id;
-                const buffer = {
-                    ...baseProps.buffer,
-                    text: currentText,
-                    lines: currentLines,
-                    viewportVisualLines: currentLines,
-                    allVisualLines: currentLines,
-                    viewportHeight: 10,
-                    pastedContent: { [id]: largeText },
-                    transformationsByLine: isExpanded
-                        ? currentLines.map(() => [])
-                        : [
-                            [
-                                {
-                                    logStart: 0,
-                                    logEnd: id.length,
-                                    logicalText: id,
-                                    collapsedText: id,
-                                    type: 'paste',
-                                    id,
-                                },
-                            ],
-                        ],
-                    visualScrollRow: 0,
-                    visualToLogicalMap: currentLines.map((_, i) => [i, 0]),
-                    visualToTransformedMap: currentLines.map(() => 0),
-                    getLogicalPositionFromVisual: vi.fn().mockImplementation((_vRow, _vCol) => 
-                    // Simulate that we are past the end of the line by returning something
-                    // that getTransformUnderCursor won't match, or having the caller handle it.
-                    null),
-                    togglePasteExpansion: vi.fn().mockImplementation(() => {
-                        setIsExpanded(!isExpanded);
-                    }),
-                    getExpandedPasteAtLine: vi
-                        .fn()
-                        .mockImplementation((row) => isExpanded && row >= 0 && row < 10 ? id : null),
-                };
-                return _jsx(TestInputPrompt, { ...baseProps, buffer: buffer });
-            };
-            const { stdout, unmount, simulateClick } = await renderWithProviders(_jsx(TestWrapper, {}), {
-                mouseEventsEnabled: true,
-                config: makeFakeConfig({ useAlternateBuffer: true }),
-                settings: createMockSettings({ ui: { useAlternateBuffer: true } }),
-                uiActions,
-            });
-            // Verify initially expanded
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('line1');
-            });
-            // Simulate double-click WAY to the right on the first line
-            await simulateClick(90, 2);
-            await simulateClick(90, 2);
-            // Verify it is NOW collapsed
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain(id);
-                expect(stdout.lastFrame()).not.toContain('line1');
-            });
-            unmount();
-        });
-        it('should move cursor on mouse click with plain borders', async () => {
-            props.config.getUseBackgroundColor = () => false;
-            props.buffer.text = 'hello world';
-            props.buffer.lines = ['hello world'];
-            props.buffer.allVisualLines = ['hello world'];
-            props.buffer.viewportVisualLines = ['hello world'];
-            props.buffer.viewportHeight = 10;
-            props.buffer.visualToLogicalMap = [[0, 0]];
-            props.buffer.visualCursor = [0, 11];
-            props.buffer.visualScrollRow = 0;
-            const { stdin, stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { mouseEventsEnabled: true, uiActions });
-            // Wait for initial render
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello world');
-            });
-            // With plain borders offset
-            await act(async () => {
-                stdin.write(`\x1b[<0;4;2M`); // Click at col 4, row 2
-            });
-            await waitFor(() => {
-                expect(props.buffer.moveToVisualPosition).toHaveBeenCalledWith(0, 0);
-            });
-            unmount();
-        });
-    });
-    describe('queued message editing', () => {
-        it('should load all queued messages when up arrow is pressed with empty input', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue('Message 1\n\nMessage 2\n\nMessage 3');
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(props.buffer.setText).toHaveBeenCalledWith('Message 1\n\nMessage 2\n\nMessage 3');
-            unmount();
-        });
-        it('should not load queued messages when input is not empty', async () => {
-            const mockPopAllMessages = vi.fn();
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = 'some text';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-            expect(mockPopAllMessages).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should handle undefined messages from popAllMessages', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue(undefined);
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(props.buffer.setText).not.toHaveBeenCalled();
-            expect(mockInputHistory.navigateUp).toHaveBeenCalled();
-            unmount();
-        });
-        it('should work with NAVIGATION_UP key as well', async () => {
-            const mockPopAllMessages = vi.fn();
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            props.buffer.allVisualLines = [''];
-            props.buffer.visualCursor = [0, 0];
-            props.buffer.visualScrollRow = 0;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            unmount();
-        });
-        it('should handle single queued message', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue('Single message');
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(props.buffer.setText).toHaveBeenCalledWith('Single message');
-            unmount();
-        });
-        it('should only check for queued messages when buffer text is trimmed empty', async () => {
-            const mockPopAllMessages = vi.fn();
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '   '; // Whitespace only
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            unmount();
-        });
-        it('should not call popAllMessages if it is not provided', async () => {
-            props.popAllMessages = undefined;
-            props.buffer.text = '';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-            unmount();
-        });
-        it('should navigate input history on fresh start when no queued messages exist', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue(undefined);
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(mockInputHistory.navigateUp).toHaveBeenCalled();
-            expect(props.buffer.setText).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('snapshots', () => {
-        it('should render correctly in shell mode', async () => {
-            props.shellModeActive = true;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await waitFor(() => expect(stdout.lastFrame()).toContain('!'));
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should render correctly when accepting edits', async () => {
-            props.approvalMode = ApprovalMode.AUTO_EDIT;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await waitFor(() => expect(stdout.lastFrame()).toContain('>'));
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should render correctly in yolo mode', async () => {
-            props.approvalMode = ApprovalMode.YOLO;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await waitFor(() => expect(stdout.lastFrame()).toContain('*'));
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should not show inverted cursor when shell is focused', async () => {
-            props.isEmbeddedShellFocused = true;
-            props.focus = false;
-            const renderResult = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await renderResult.waitUntilReady();
-            await expect(renderResult).toMatchSvgSnapshot();
-            renderResult.unmount();
-        });
-    });
-    it('should still allow input when shell is not focused', async () => {
-        const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-            shellFocus: false,
-        });
-        await act(async () => {
-            stdin.write('a');
-        });
-        await waitFor(() => expect(mockBuffer.handleInput).toHaveBeenCalled());
-        unmount();
-    });
-    describe('command queuing while streaming', () => {
-        beforeEach(() => {
-            props.streamingState = StreamingState.Responding;
-            props.setQueueErrorMessage = vi.fn();
-            props.onSubmit = vi.fn();
-        });
-        it.each([
-            {
-                name: 'should prevent slash commands',
-                bufferText: '/help',
-                shellMode: false,
-                shouldSubmit: false,
-                errorMessage: 'Slash commands cannot be queued',
-            },
-            {
-                name: 'should allow concurrent-safe slash commands',
-                bufferText: '/stats',
-                shellMode: false,
-                shouldSubmit: true,
-                errorMessage: null,
-            },
-            {
-                name: 'should prevent shell commands',
-                bufferText: 'ls',
-                shellMode: true,
-                shouldSubmit: false,
-                errorMessage: 'Shell commands cannot be queued',
-            },
-            {
-                name: 'should allow regular messages',
-                bufferText: 'regular message',
-                shellMode: false,
-                shouldSubmit: true,
-                errorMessage: null,
-            },
-        ])('$name', async ({ bufferText, shellMode, shouldSubmit, errorMessage }) => {
-            props.buffer.text = bufferText;
-            props.shellModeActive = shellMode;
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await waitFor(() => {
-                if (shouldSubmit) {
-                    expect(props.onSubmit).toHaveBeenCalledWith(bufferText);
-                    expect(props.setQueueErrorMessage).not.toHaveBeenCalled();
-                }
-                else {
-                    expect(props.onSubmit).not.toHaveBeenCalled();
-                    expect(props.setQueueErrorMessage).toHaveBeenCalledWith(errorMessage);
-                }
-            });
-            unmount();
-        });
-    });
-    describe('IME Cursor Support', () => {
-        it('should report correct cursor position for simple ASCII text', async () => {
-            const text = 'hello';
-            mockBuffer.setText(text);
-            mockBuffer.visualCursor = [0, 3]; // Cursor after 'hel'
-            mockBuffer.visualScrollRow = 0;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello');
-            });
-            // Check Text calls from the LAST render
-            const textCalls = vi.mocked(Text).mock.calls;
-            const cursorLineCall = [...textCalls]
-                .reverse()
-                .find((call) => call[0].terminalCursorFocus === true);
-            expect(cursorLineCall).toBeDefined();
-            // 'hel' is 3 characters wide
-            expect(cursorLineCall[0].terminalCursorPosition).toBe(3);
-            unmount();
-        });
-        it('should report correct cursor position for text with double-width characters', async () => {
-            const text = '👍hello';
-            mockBuffer.setText(text);
-            mockBuffer.visualCursor = [0, 2]; // Cursor after '👍h' (Note: '👍' is one code point but width 2)
-            mockBuffer.visualScrollRow = 0;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('👍hello');
-            });
-            const textCalls = vi.mocked(Text).mock.calls;
-            const cursorLineCall = [...textCalls]
-                .reverse()
-                .find((call) => call[0].terminalCursorFocus === true);
-            expect(cursorLineCall).toBeDefined();
-            // '👍' is width 2, 'h' is width 1. Total width = 3.
-            expect(cursorLineCall[0].terminalCursorPosition).toBe(3);
-            unmount();
-        });
-        it('should report correct cursor position for a line full of "😀" emojis', async () => {
-            const text = '😀😀😀';
-            mockBuffer.setText(text);
-            mockBuffer.visualCursor = [0, 2]; // Cursor after 2 emojis (each 1 code point, width 2)
-            mockBuffer.visualScrollRow = 0;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('😀😀😀');
-            });
-            const textCalls = vi.mocked(Text).mock.calls;
-            const cursorLineCall = [...textCalls]
-                .reverse()
-                .find((call) => call[0].terminalCursorFocus === true);
-            expect(cursorLineCall).toBeDefined();
-            // 2 emojis * width 2 = 4
-            expect(cursorLineCall[0].terminalCursorPosition).toBe(4);
-            unmount();
-        });
-        it('should report correct cursor position for mixed emojis and multi-line input', async () => {
-            const lines = ['😀😀', 'hello 😀', 'world'];
-            mockBuffer.text = lines.join('\n');
-            mockBuffer.lines = lines;
-            mockBuffer.allVisualLines = lines;
-            mockBuffer.viewportVisualLines = lines;
-            mockBuffer.viewportHeight = 10;
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-                [2, 0],
-            ];
-            mockBuffer.visualCursor = [1, 7]; // Second line, after 'hello 😀' (6 chars + 1 emoji = 7 code points)
-            mockBuffer.visualScrollRow = 0;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello 😀');
-            });
-            const textCalls = vi.mocked(Text).mock.calls;
-            const lineCalls = textCalls.filter((call) => call[0].terminalCursorPosition !== undefined);
-            const lastRenderLineCalls = lineCalls.slice(-3);
-            const focusCall = lastRenderLineCalls.find((call) => call[0].terminalCursorFocus === true);
-            expect(focusCall).toBeDefined();
-            // 'hello ' is 6 units, '😀' is 2 units. Total = 8.
-            expect(focusCall[0].terminalCursorPosition).toBe(8);
-            unmount();
-        });
-        it('should report correct cursor position and focus for multi-line input', async () => {
-            const lines = ['first line', 'second line', 'third line'];
-            mockBuffer.text = lines.join('\n');
-            mockBuffer.lines = lines;
-            mockBuffer.allVisualLines = lines;
-            mockBuffer.viewportVisualLines = lines;
-            mockBuffer.viewportHeight = 10;
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-                [2, 0],
-            ];
-            mockBuffer.visualCursor = [1, 7]; // Cursor on second line, after 'second '
-            mockBuffer.visualScrollRow = 0;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('second line');
-            });
-            const textCalls = vi.mocked(Text).mock.calls;
-            // We look for the last set of line calls.
-            // Line calls have terminalCursorPosition set.
-            const lineCalls = textCalls.filter((call) => call[0].terminalCursorPosition !== undefined);
-            const lastRenderLineCalls = lineCalls.slice(-3);
-            expect(lastRenderLineCalls.length).toBe(3);
-            // Only one line should have terminalCursorFocus=true
-            const focusCalls = lastRenderLineCalls.filter((call) => call[0].terminalCursorFocus === true);
-            expect(focusCalls.length).toBe(1);
-            expect(focusCalls[0][0].terminalCursorPosition).toBe(7);
-            unmount();
-        });
-        it('should report cursor position 0 when input is empty and placeholder is shown', async () => {
-            mockBuffer.text = '';
-            mockBuffer.lines = [''];
-            mockBuffer.allVisualLines = [''];
-            mockBuffer.viewportVisualLines = [''];
-            mockBuffer.visualToLogicalMap = [[0, 0]];
-            mockBuffer.visualCursor = [0, 0];
-            mockBuffer.visualScrollRow = 0;
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, placeholder: "Type here" }), { uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('Type here');
-            });
-            const textCalls = vi.mocked(Text).mock.calls;
-            const cursorLineCall = [...textCalls]
-                .reverse()
-                .find((call) => call[0].terminalCursorFocus === true);
-            expect(cursorLineCall).toBeDefined();
-            expect(cursorLineCall[0].terminalCursorPosition).toBe(0);
-            unmount();
-        });
-    });
-    describe('image path transformation snapshots', () => {
-        const logicalLine = '@/path/to/screenshots/screenshot2x.png';
-        const transformations = calculateTransformationsForLine(logicalLine);
-        const applyVisualState = (visualLine, cursorCol) => {
-            mockBuffer.text = logicalLine;
-            mockBuffer.lines = [logicalLine];
-            mockBuffer.allVisualLines = [visualLine];
-            mockBuffer.viewportVisualLines = [visualLine];
-            mockBuffer.visualToLogicalMap = [[0, 0]];
-            mockBuffer.visualToTransformedMap = [0];
-            mockBuffer.transformationsByLine = [transformations];
-            mockBuffer.cursor = [0, cursorCol];
-            mockBuffer.visualCursor = [0, cursorCol];
-            mockBuffer.visualScrollRow = 0;
-        };
-        it('should snapshot collapsed image path', async () => {
-            const { transformedLine } = calculateTransformedLine(logicalLine, 0, [0, transformations[0].logEnd + 5], transformations);
-            applyVisualState(transformedLine, transformations[0].logEnd + 5);
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('[Image');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should snapshot expanded image path when cursor is on it', async () => {
-            const { transformedLine } = calculateTransformedLine(logicalLine, 0, [0, transformations[0].logStart + 1], transformations);
-            applyVisualState(transformedLine, transformations[0].logStart + 1);
-            const { stdout, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }));
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('@/path/to/screenshots');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-    });
-    describe('Ctrl+O paste expansion', () => {
-        const CTRL_O = '\x0f'; // Ctrl+O key sequence
-        it('Ctrl+O triggers paste expansion via keybinding', async () => {
-            const id = '[Pasted Text: 10 lines]';
-            const toggleFn = vi.fn();
-            const buffer = {
-                ...props.buffer,
-                text: id,
-                cursor: [0, 0],
-                pastedContent: {
-                    [id]: 'line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10',
-                },
-                transformationsByLine: [
-                    [
-                        {
-                            logStart: 0,
-                            logEnd: id.length,
-                            logicalText: id,
-                            collapsedText: id,
-                            type: 'paste',
-                            id,
-                        },
-                    ],
-                ],
-                expandedPaste: null,
-                getExpandedPasteAtLine: vi.fn().mockReturnValue(null),
-                togglePasteExpansion: toggleFn,
-            };
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, buffer: buffer }), { uiActions });
-            await act(async () => {
-                stdin.write(CTRL_O);
-            });
-            await waitFor(() => {
-                expect(toggleFn).toHaveBeenCalledWith(id, 0, 0);
-            });
-            unmount();
-        });
-        it.each([
-            {
-                name: 'hint appears on large paste via Ctrl+V',
-                text: 'line1\nline2\nline3\nline4\nline5\nline6',
-                method: 'ctrl-v',
-                expectHint: true,
-            },
-            {
-                name: 'hint does not appear for small pastes via Ctrl+V',
-                text: 'hello',
-                method: 'ctrl-v',
-                expectHint: false,
-            },
-            {
-                name: 'hint appears on large terminal paste event',
-                text: 'line1\nline2\nline3\nline4\nline5\nline6',
-                method: 'terminal-paste',
-                expectHint: true,
-            },
-        ])('$name', async ({ text, method, expectHint }) => {
-            vi.mocked(clipboardy.read).mockResolvedValue(text);
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const emitSpy = vi.spyOn(appEvents, 'emit');
-            const buffer = {
-                ...props.buffer,
-                handleInput: vi.fn().mockReturnValue(true),
-            };
-            // Need kitty protocol enabled for terminal paste events
-            if (method === 'terminal-paste') {
-                mockedUseKittyKeyboardProtocol.mockReturnValue({
-                    enabled: true,
-                    checking: false,
-                });
-            }
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, buffer: method === 'terminal-paste' ? buffer : props.buffer }));
-            await act(async () => {
-                if (method === 'ctrl-v') {
-                    stdin.write('\x16'); // Ctrl+V
-                }
-                else {
-                    stdin.write(`\x1b[200~${text}\x1b[201~`);
-                }
-            });
-            await waitFor(() => {
-                if (expectHint) {
-                    expect(emitSpy).toHaveBeenCalledWith(AppEvent.TransientMessage, {
-                        message: 'Press Ctrl+O to expand pasted text',
-                        type: TransientMessageType.Hint,
-                    });
-                }
-                else {
-                    // If no hint expected, verify buffer was still updated
-                    if (method === 'ctrl-v') {
-                        expect(mockBuffer.insert).toHaveBeenCalledWith(text, {
-                            paste: true,
-                        });
-                    }
-                    else {
-                        expect(buffer.handleInput).toHaveBeenCalled();
-                    }
-                }
-            });
-            if (!expectHint) {
-                expect(emitSpy).not.toHaveBeenCalledWith(AppEvent.TransientMessage, expect.any(Object));
-            }
-            emitSpy.mockRestore();
-            unmount();
-        });
-    });
-    describe('tryTogglePasteExpansion', () => {
-        it.each([
-            {
-                name: 'returns false when no pasted content exists',
-                cursor: [0, 0],
-                pastedContent: {},
-                getExpandedPasteAtLine: null,
-                expected: false,
-            },
-            {
-                name: 'expands placeholder under cursor',
-                cursor: [0, 2],
-                pastedContent: { '[Pasted Text: 6 lines]': 'content' },
-                transformations: [
-                    {
-                        logStart: 0,
-                        logEnd: '[Pasted Text: 6 lines]'.length,
-                        id: '[Pasted Text: 6 lines]',
-                    },
-                ],
-                expected: true,
-                expectedToggle: ['[Pasted Text: 6 lines]', 0, 2],
-            },
-            {
-                name: 'collapses expanded paste when cursor is inside',
-                cursor: [1, 0],
-                pastedContent: { '[Pasted Text: 6 lines]': 'a\nb\nc' },
-                getExpandedPasteAtLine: '[Pasted Text: 6 lines]',
-                expected: true,
-                expectedToggle: ['[Pasted Text: 6 lines]', 1, 0],
-            },
-            {
-                name: 'expands placeholder when cursor is immediately after it',
-                cursor: [0, '[Pasted Text: 6 lines]'.length],
-                pastedContent: { '[Pasted Text: 6 lines]': 'content' },
-                transformations: [
-                    {
-                        logStart: 0,
-                        logEnd: '[Pasted Text: 6 lines]'.length,
-                        id: '[Pasted Text: 6 lines]',
-                    },
-                ],
-                expected: true,
-                expectedToggle: [
-                    '[Pasted Text: 6 lines]',
-                    0,
-                    '[Pasted Text: 6 lines]'.length,
-                ],
-            },
-            {
-                name: 'shows hint when cursor is not on placeholder but placeholders exist',
-                cursor: [0, 0],
-                pastedContent: { '[Pasted Text: 6 lines]': 'content' },
-                transformationsByLine: [
-                    [],
-                    [
-                        {
-                            logStart: 0,
-                            logEnd: '[Pasted Text: 6 lines]'.length,
-                            type: 'paste',
-                            id: '[Pasted Text: 6 lines]',
-                        },
-                    ],
-                ],
-                expected: true,
-                expectedHint: 'Move cursor within placeholder to expand',
-            },
-        ])('$name', ({ cursor, pastedContent, transformations, transformationsByLine, getExpandedPasteAtLine, expected, expectedToggle, expectedHint, }) => {
-            const id = '[Pasted Text: 6 lines]';
-            const buffer = {
-                cursor,
-                pastedContent,
-                transformationsByLine: transformationsByLine || [
-                    transformations
-                        ? transformations.map((t) => ({
-                            ...t,
-                            logicalText: id,
-                            collapsedText: id,
-                            type: 'paste',
-                        }))
-                        : [],
-                ],
-                getExpandedPasteAtLine: vi
-                    .fn()
-                    .mockReturnValue(getExpandedPasteAtLine),
-                togglePasteExpansion: vi.fn(),
-            };
-            const emitSpy = vi.spyOn(appEvents, 'emit');
-            expect(tryTogglePasteExpansion(buffer)).toBe(expected);
-            if (expectedToggle) {
-                expect(buffer.togglePasteExpansion).toHaveBeenCalledWith(...expectedToggle);
-            }
-            else {
-                expect(buffer.togglePasteExpansion).not.toHaveBeenCalled();
-            }
-            if (expectedHint) {
-                expect(emitSpy).toHaveBeenCalledWith(AppEvent.TransientMessage, {
-                    message: expectedHint,
-                    type: TransientMessageType.Hint,
-                });
-            }
-            else {
-                expect(emitSpy).not.toHaveBeenCalledWith(AppEvent.TransientMessage, expect.any(Object));
-            }
-            emitSpy.mockRestore();
-        });
-    });
-    describe('History Navigation and Completion Suppression', () => {
-        beforeEach(() => {
-            props.userMessages = ['first message', 'second message'];
-            // Mock useInputHistory to actually call onChange
-            mockedUseInputHistory.mockImplementation(({ onChange, onSubmit }) => ({
-                navigateUp: () => {
-                    onChange('second message', 'start');
-                    return true;
-                },
-                navigateDown: () => {
-                    onChange('first message', 'end');
-                    return true;
-                },
-                handleSubmit: vi.fn((val) => onSubmit(val)),
-            }));
-        });
-        it.each([
-            { name: 'Up arrow', key: '\u001B[A', position: 'start' },
-            { name: 'Ctrl+P', key: '\u0010', position: 'start' },
-        ])('should move cursor to $position on $name (older history)', async ({ key, position }) => {
-            const { stdin } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write(key);
-            });
-            await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('second message', position);
-            });
-        });
-        it.each([
-            { name: 'Down arrow', key: '\u001B[B', position: 'end' },
-            { name: 'Ctrl+N', key: '\u000E', position: 'end' },
-        ])('should move cursor to $position on $name (newer history)', async ({ key, position }) => {
-            const { stdin } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            // First go up
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            // Then go down
-            await act(async () => {
-                stdin.write(key);
-                if (key === '\u001B[B') {
-                    // Second press to actually navigate history
-                    stdin.write(key);
-                }
-            });
-            await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('first message', position);
-            });
-        });
-        it('should suppress completion after history navigation', async () => {
-            const { stdin } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            await act(async () => {
-                stdin.write('\u001B[A'); // Up arrow
-            });
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenLastCalledWith({
-                    buffer: mockBuffer,
-                    cwd: expect.anything(),
-                    slashCommands: expect.anything(),
-                    commandContext: expect.anything(),
-                    reverseSearchActive: expect.anything(),
-                    shellModeActive: expect.anything(),
-                    config: expect.anything(),
-                    active: false,
-                });
-            });
-        });
-        it('should not render suggestions during history navigation', async () => {
-            // 1. Set up a dynamic mock implementation BEFORE rendering
-            mockedUseCommandCompletion.mockImplementation(({ active }) => ({
-                ...mockCommandCompletion,
-                showSuggestions: active,
-                suggestions: active
-                    ? [{ value: 'suggestion', label: 'suggestion' }]
-                    : [],
-            }));
-            const { stdout, stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            // 2. Verify suggestions ARE showing initially because active is true by default
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('suggestion');
-            });
-            // 3. Trigger history navigation which should set suppressCompletion to true
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            // 4. Verify that suggestions are NOT in the output frame after navigation
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('suggestion');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should continue to suppress completion after manual cursor movement', async () => {
-            const { stdin } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            // Navigate history (suppresses)
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            // Wait for it to be suppressed
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenLastCalledWith({
-                    buffer: mockBuffer,
-                    cwd: expect.anything(),
-                    slashCommands: expect.anything(),
-                    commandContext: expect.anything(),
-                    reverseSearchActive: expect.anything(),
-                    shellModeActive: expect.anything(),
-                    config: expect.anything(),
-                    active: false,
-                });
-            });
-            // Move cursor manually
-            await act(async () => {
-                stdin.write('\u001B[D'); // Left arrow
-            });
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenLastCalledWith({
-                    buffer: mockBuffer,
-                    cwd: expect.anything(),
-                    slashCommands: expect.anything(),
-                    commandContext: expect.anything(),
-                    reverseSearchActive: expect.anything(),
-                    shellModeActive: expect.anything(),
-                    config: expect.anything(),
-                    active: false,
-                });
-            });
-        });
-        it('should re-enable completion after typing', async () => {
-            const { stdin } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiActions,
-            });
-            // Navigate history (suppresses)
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            // Wait for it to be suppressed
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenLastCalledWith(expect.objectContaining({ active: false }));
-            });
-            // Type a character
-            await act(async () => {
-                stdin.write('a');
-            });
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenLastCalledWith(expect.objectContaining({ active: true }));
-            });
-        });
-    });
-    describe('shortcuts help visibility', () => {
-        it('opens shortcuts help with ? on empty prompt even when showShortcutsHint is false', async () => {
-            const setShortcutsHelpVisible = vi.fn();
-            const settings = createMockSettings({
-                ui: { showShortcutsHint: false },
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                settings,
-                uiActions: { setShortcutsHelpVisible },
-            });
-            await act(async () => {
-                stdin.write('?');
-            });
-            await waitFor(() => {
-                expect(setShortcutsHelpVisible).toHaveBeenCalledWith(true);
-            });
-            unmount();
-        });
-        it('should NOT open shortcuts help with ? in vim NORMAL mode', async () => {
-            const setShortcutsHelpVisible = vi.fn();
-            const vimHandleInput = vi.fn().mockReturnValue(true);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, vimEnabled: true, vimMode: "NORMAL", vimHandleInput: vimHandleInput }), {
-                uiActions: { setShortcutsHelpVisible },
-            });
-            await act(async () => {
-                stdin.write('?');
-            });
-            expect(setShortcutsHelpVisible).not.toHaveBeenCalled();
-            expect(vimHandleInput).toHaveBeenCalled();
-            expect(mockBuffer.handleInput).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should open shortcuts help with ? in vim INSERT mode', async () => {
-            const setShortcutsHelpVisible = vi.fn();
-            const vimHandleInput = vi.fn().mockReturnValue(false);
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, vimEnabled: true, vimMode: "INSERT", vimHandleInput: vimHandleInput }), {
-                uiActions: { setShortcutsHelpVisible },
-            });
-            await act(async () => {
-                stdin.write('?');
-            });
-            await waitFor(() => {
-                expect(setShortcutsHelpVisible).toHaveBeenCalledWith(true);
-            });
-            unmount();
-        });
-        it.each([
-            {
-                name: 'terminal paste event occurs',
-                input: '\x1b[200~pasted text\x1b[201~',
-            },
-            {
-                name: 'Ctrl+V (PASTE_CLIPBOARD) is pressed',
-                input: '\x16',
-                setupMocks: () => {
-                    vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-                    vi.mocked(clipboardy.read).mockResolvedValue('clipboard text');
-                },
-            },
-            {
-                name: 'mouse right-click paste occurs',
-                input: '\x1b[<2;1;1m',
-                mouseEventsEnabled: true,
-                setupMocks: () => {
-                    vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-                    vi.mocked(clipboardy.read).mockResolvedValue('clipboard text');
-                },
-            },
-            {
-                name: 'Ctrl+R hotkey is pressed',
-                input: '\x12',
-            },
-            {
-                name: 'Ctrl+G hotkey is pressed',
-                input: '\x07',
-            },
-            {
-                name: 'F12 hotkey is pressed',
-                input: '\x1b[24~',
-            },
-        ])('should close shortcuts help when a $name', async ({ input, setupMocks, mouseEventsEnabled }) => {
-            setupMocks?.();
-            const setShortcutsHelpVisible = vi.fn();
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), {
-                uiState: { shortcutsHelpVisible: true },
-                uiActions: { setShortcutsHelpVisible },
-                mouseEventsEnabled,
-            });
-            await act(async () => {
-                stdin.write(input);
-            });
-            await waitFor(() => {
-                expect(setShortcutsHelpVisible).toHaveBeenCalledWith(false);
-            });
-            unmount();
-        });
-    });
-    describe('Voice Mode', () => {
-        beforeEach(() => {
-            fakeTranscriptionProvider.removeAllListeners();
-            vi.clearAllMocks();
-        });
-        it('should start recording when space is pressed and voice mode is enabled (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('');
-            });
-            const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: true },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            // Initially not recording
-            expect(lastFrame()).toContain('🎤 >');
-            expect(lastFrame()).toContain('Type your message or space to talk (Esc to exit)');
-            // Press space to start
-            await act(async () => {
-                stdin.write(' ');
-            });
-            unmount();
-        });
-        it('should toggle recording off when space is pressed again (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('');
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: true },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            // Start recording
-            await act(async () => {
-                stdin.write(' ');
-            });
-            // Stop recording
-            await act(async () => {
-                stdin.write(' ');
-            });
-            unmount();
-        });
-        it('should resume recording when space is pressed even if buffer is not empty (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('First turn.');
-            });
-            const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: true },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            // Should show voice mode prefix even if buffer is not empty
-            expect(lastFrame()).toContain('🎤 >');
-            expect(lastFrame()).toContain('First turn.');
-            // Press space to start recording again
-            await act(async () => {
-                stdin.write(' ');
-            });
-            unmount();
-        });
-        it('should not start recording if voice mode is disabled (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('');
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: false },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            // Press space
-            await act(async () => {
-                stdin.write(' ');
-            });
-            // Should NOT show listening, instead should call handleInput which handles space
-            expect(mockBuffer.handleInput).toHaveBeenCalled();
-            unmount();
-        });
-        it('should append transcription correctly across multiple turn updates (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('initial');
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: true },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            // Start recording
-            await act(async () => {
-                stdin.write(' ');
-            });
-            // Emit first transcription
-            await act(async () => {
-                fakeTranscriptionProvider.emit('transcription', 'hello');
-            });
-            await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('initial hello', 13);
-            });
-            // turnComplete advances the baseline; next turn appends after it
-            await act(async () => {
-                fakeTranscriptionProvider.emit('turnComplete');
-            });
-            await act(async () => {
-                fakeTranscriptionProvider.emit('transcription', 'world');
-            });
-            await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('initial hello world', 19);
-            });
-            unmount();
-        });
-        it('should append transcription correctly when resuming voice mode (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('First turn.');
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: true },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            // Start recording (resumed)
-            await act(async () => {
-                stdin.write(' ');
-            });
-            // Emit transcription
-            await act(async () => {
-                fakeTranscriptionProvider.emit('transcription', 'Second turn.');
-            });
-            await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('First turn. Second turn.', 24);
-            });
-            unmount();
-        });
-        it('should insert transcription at cursor position when buffer has text before and after (toggle)', async () => {
-            await act(async () => {
-                mockBuffer.setText('hello world');
-                mockBuffer.cursor = [0, 5]; // cursor after 'hello'
-            });
-            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                uiState: { isVoiceModeEnabled: true },
-                settings: createMockSettings({
-                    experimental: { voice: { activationMode: 'toggle' } },
-                }),
-            });
-            await act(async () => {
-                stdin.write(' ');
-            });
-            await act(async () => {
-                fakeTranscriptionProvider.emit('transcription', 'there');
-            });
-            // 'hello'(5) + ' '(1) + 'there'(5) = cursor at 11; ' world' preserved after
-            await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('hello there world', 11);
-            });
-            unmount();
-        });
-        describe('push-to-talk', () => {
-            beforeEach(() => {
-                vi.useFakeTimers();
-            });
-            afterEach(() => {
-                vi.useRealTimers();
-            });
-            it('should insert a space on a single tap', async () => {
-                const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                    uiState: { isVoiceModeEnabled: true },
-                    settings: createMockSettings({
-                        experimental: { voice: { activationMode: 'push-to-talk' } },
-                    }),
-                });
-                expect(lastFrame()).toContain('🎤 >');
-                expect(lastFrame()).toContain('Type your message or hold space to talk (Esc to exit)');
-                // Press space once
-                await act(async () => {
-                    stdin.write(' ');
-                });
-                // Should insert space optimistically
-                expect(mockBuffer.insert).toHaveBeenCalledWith(' ');
-                // Advance timer past HOLD_DELAY_MS
-                await act(async () => {
-                    vi.advanceTimersByTime(700);
-                });
-                unmount();
-            });
-            it('should start recording on hold (simulated by repeat spaces)', async () => {
-                const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                    uiState: { isVoiceModeEnabled: true },
-                    settings: createMockSettings({
-                        experimental: { voice: { activationMode: 'push-to-talk' } },
-                    }),
-                });
-                // First space
-                await act(async () => {
-                    stdin.write(' ');
-                });
-                expect(mockBuffer.insert).toHaveBeenCalledWith(' ');
-                // Second space (repeat)
-                await act(async () => {
-                    stdin.write(' ');
-                });
-                await waitFor(() => {
-                    // Should have backspaced the optimistic space
-                    expect(mockBuffer.backspace).toHaveBeenCalled();
-                });
-                unmount();
-            });
-            it('should stop recording when space heartbeat stops (release)', async () => {
-                const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                    uiState: { isVoiceModeEnabled: true },
-                    settings: createMockSettings({
-                        experimental: { voice: { activationMode: 'push-to-talk' } },
-                    }),
-                });
-                // Start hold
-                await act(async () => {
-                    stdin.write(' ');
-                    stdin.write(' ');
-                });
-                // Simulate heartbeat (held key) - send space first to reset timer, then advance
-                await act(async () => {
-                    stdin.write(' ');
-                    vi.advanceTimersByTime(100);
-                });
-                expect(lastFrame()).toContain('~~~ >');
-                // Stop heartbeat (release)
-                await act(async () => {
-                    vi.advanceTimersByTime(400); // Past RELEASE_DELAY_MS
-                });
-                unmount();
-            });
-            it('should cancel hold state if non-space key is pressed after first space', async () => {
-                const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
-                    uiState: { isVoiceModeEnabled: true },
-                    settings: createMockSettings({
-                        experimental: { voice: { activationMode: 'push-to-talk' } },
-                    }),
-                });
-                // First space
-                await act(async () => {
-                    stdin.write(' ');
-                });
-                // Type 'a'
-                await act(async () => {
-                    stdin.write('a');
-                });
-                // Should NOT start recording on next space even if fast
-                await act(async () => {
-                    stdin.write(' ');
-                });
-                expect(mockBuffer.insert).toHaveBeenCalledTimes(2); // Two spaces inserted
-                expect(mockBuffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({ name: 'a' }));
-                unmount();
-            });
-        });
-    });
-    describe('terminal buffer rendering', () => {
-        it('does not clip the last char of a visual line whose width equals inputWidth', async () => {
-            const fullLine = '1234567890'; // 10 chars, exactly props.inputWidth
-            props.inputWidth = 10;
-            props.suggestionsWidth = 10;
-            vi.spyOn(props.config, 'getUseTerminalBuffer').mockReturnValue(true);
-            mockBuffer.text = fullLine;
-            mockBuffer.lines = [fullLine];
-            mockBuffer.allVisualLines = [fullLine];
-            mockBuffer.viewportVisualLines = [fullLine];
-            mockBuffer.visualToLogicalMap = [[0, 0]];
-            mockBuffer.visualToTransformedMap = [0];
-            mockBuffer.transformationsByLine = [[]];
-            mockBuffer.cursor = [0, fullLine.length];
-            mockBuffer.visualCursor = [0, fullLine.length];
-            const { lastFrame, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
-            await waitFor(() => {
-                expect(clean(lastFrame())).toContain(fullLine);
-            });
-            unmount();
-        });
-    });
-});
-function clean(str) {
-    if (!str)
-        return '';
-    // Remove ANSI escape codes and trim whitespace
-    return stripAnsi(str).trim();
-}
-//# sourceMappingURL=InputPrompt.test.js.map