@mmmbuto/gemini-cli-termux 0.30.3-termux → 0.30.5-termux

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

@@ -4,10 +4,11 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { renderWithProviders, createMockSettings, } from '../../test-utils/render.js';
+import { renderWithProviders } from '../../test-utils/render.js';
+import { createMockSettings } from '../../test-utils/settings.js';
 import { waitFor } from '../../test-utils/async.js';
 import { act, useState } from 'react';
-import { InputPrompt } from './InputPrompt.js';
+import { InputPrompt, tryTogglePasteExpansion } from './InputPrompt.js';
 import { calculateTransformationsForLine, calculateTransformedLine, } from './shared/text-buffer.js';
 import { ApprovalMode, debugLogger } from '@google/gemini-cli-core';
 import * as path from 'node:path';
@@ -27,7 +28,9 @@ import chalk from 'chalk';
 import { StreamingState } from '../types.js';
 import { terminalCapabilityManager } from '../utils/terminalCapabilityManager.js';
 import { isLowColorDepth } from '../utils/terminalUtils.js';
+import { cpLen } from '../utils/textUtils.js';
 import { keyMatchers, Command } from '../keyMatchers.js';
+import { appEvents, AppEvent, TransientMessageType, } from '../../utils/events.js';
 vi.mock('../hooks/useShellHistory.js');
 vi.mock('../hooks/useCommandCompletion.js');
 vi.mock('../hooks/useInputHistory.js');
@@ -46,6 +49,9 @@ vi.mock('ink', async (importOriginal) => {
         Text: vi.fn(({ children, ...props }) => (_jsx(actual.Text, { ...props, children: children }))),
     };
 });
+afterEach(() => {
+    vi.restoreAllMocks();
+});
 const mockSlashCommands = [
     {
         name: 'clear',
@@ -113,8 +119,14 @@ describe('InputPrompt', () => {
     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,
     };
     beforeEach(() => {
         vi.resetAllMocks();
@@ -124,13 +136,24 @@ describe('InputPrompt', () => {
             text: '',
             cursor: [0, 0],
             lines: [''],
-            setText: vi.fn((newText) => {
+            setText: vi.fn((newText, cursorPosition) => {
                 mockBuffer.text = newText;
                 mockBuffer.lines = [newText];
-                mockBuffer.cursor = [0, newText.length];
+                let col = 0;
+                if (typeof cursorPosition === 'number') {
+                    col = cursorPosition;
+                }
+                else if (cursorPosition === 'start') {
+                    col = 0;
+                }
+                else {
+                    col = newText.length;
+                }
+                mockBuffer.cursor = [0, col];
                 mockBuffer.viewportVisualLines = [newText];
                 mockBuffer.allVisualLines = [newText];
                 mockBuffer.visualToLogicalMap = [[0, 0]];
+                mockBuffer.visualCursor = [0, col];
             }),
             replaceRangeByOffset: vi.fn(),
             viewportVisualLines: [''],
@@ -147,7 +170,15 @@ describe('InputPrompt', () => {
                 }
                 return false;
             }),
-            move: vi.fn(),
+            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];
             }),
@@ -191,7 +222,6 @@ describe('InputPrompt', () => {
             navigateDown: vi.fn(),
             resetCompletionState: vi.fn(),
             setActiveSuggestionIndex: vi.fn(),
-            setShowSuggestions: vi.fn(),
             handleAutocomplete: vi.fn(),
             promptCompletion: {
                 text: '',
@@ -218,7 +248,10 @@ describe('InputPrompt', () => {
             navigateDown: vi.fn(),
             handleSubmit: vi.fn(),
         };
-        mockedUseInputHistory.mockReturnValue(mockInputHistory);
+        mockedUseInputHistory.mockImplementation(({ onSubmit }) => {
+            mockInputHistory.handleSubmit = vi.fn((val) => onSubmit(val));
+            return mockInputHistory;
+        });
         mockReverseSearchCompletion = {
             suggestions: [],
             activeSuggestionIndex: -1,
@@ -322,11 +355,11 @@ describe('InputPrompt', () => {
             uiActions,
         });
         await act(async () => {
-            stdin.write('\u001B[A'); // Up arrow
+            stdin.write('\u0010'); // Ctrl+P
         });
         await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
         await act(async () => {
-            stdin.write('\u001B[B'); // Down arrow
+            stdin.write('\u000E'); // Ctrl+N
         });
         await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
         await act(async () => {
@@ -338,6 +371,72 @@ describe('InputPrompt', () => {
         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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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,
@@ -398,11 +497,11 @@ describe('InputPrompt', () => {
             uiActions,
         });
         await act(async () => {
-            stdin.write('\u001B[A'); // Up arrow
+            stdin.write('\u0010'); // Ctrl+P
         });
         await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
         await act(async () => {
-            stdin.write('\u001B[B'); // Down arrow
+            stdin.write('\u000E'); // Ctrl+N
         });
         await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
         await act(async () => {
@@ -741,6 +840,50 @@ describe('InputPrompt', () => {
         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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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',
@@ -849,6 +992,29 @@ describe('InputPrompt', () => {
         });
         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 } = renderWithProviders(_jsx(InputPrompt, { ...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',
@@ -1124,7 +1290,6 @@ describe('InputPrompt', () => {
             { color: 'black', name: 'black' },
             { color: '#000000', name: '#000000' },
             { color: '#000', name: '#000' },
-            { color: undefined, name: 'default (black)' },
             { color: 'white', name: 'white' },
             { color: '#ffffff', name: '#ffffff' },
             { color: '#fff', name: '#fff' },
@@ -1172,7 +1337,11 @@ describe('InputPrompt', () => {
         });
         it('should handle 4-bit color mode (16 colors) as low color depth', async () => {
             vi.mocked(isLowColorDepth).mockReturnValue(true);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
+            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
+                uiState: {
+                    terminalBackgroundColor: 'black',
+                },
+            });
             await waitFor(() => {
                 const frame = stdout.lastFrame();
                 expect(frame).toContain('▀');
@@ -1308,7 +1477,16 @@ describe('InputPrompt', () => {
                 uiActions,
             });
             await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
+                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();
         });
@@ -1541,7 +1719,7 @@ describe('InputPrompt', () => {
                 // This implicitly tests that the Box wrapper provides height for the empty line.
                 expect(frame).toContain('hello');
                 expect(frame).toContain(`world${chalk.inverse(' ')}`);
-                const outputLines = frame.split('\n');
+                const outputLines = frame.trim().split('\n');
                 // The number of lines should be 2 for the border plus 3 for the content.
                 expect(outputLines.length).toBe(5);
             });
@@ -1671,6 +1849,29 @@ describe('InputPrompt', () => {
             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 } = renderWithProviders(_jsx(InputPrompt, { ...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';
@@ -1967,6 +2168,28 @@ describe('InputPrompt', () => {
             });
             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 } = renderWithProviders(_jsx(InputPrompt, { ...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({
@@ -2174,32 +2397,42 @@ describe('InputPrompt', () => {
             });
             unmount();
         });
+        it('ensures Ctrl+R search results are prioritized newest-to-oldest by reversing userMessages', async () => {
+            props.shellModeActive = false;
+            props.userMessages = ['oldest', 'middle', 'newest'];
+            renderWithProviders(_jsx(InputPrompt, { ...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 focus toggle', () => {
+    describe('Tab clean UI toggle', () => {
         it.each([
             {
-                name: 'should toggle focus in on Tab when no suggestions or ghost text',
+                name: 'should toggle clean UI details on double-Tab when no suggestions or ghost text',
                 showSuggestions: false,
                 ghostText: '',
                 suggestions: [],
-                expectedFocusToggle: true,
+                expectedUiToggle: true,
             },
             {
-                name: 'should accept ghost text and NOT toggle focus on Tab',
+                name: 'should accept ghost text and NOT toggle clean UI details on Tab',
                 showSuggestions: false,
                 ghostText: 'ghost text',
                 suggestions: [],
-                expectedFocusToggle: false,
+                expectedUiToggle: false,
                 expectedAcceptCall: true,
             },
             {
-                name: 'should NOT toggle focus on Tab when suggestions are present',
+                name: 'should NOT toggle clean UI details on Tab when suggestions are present',
                 showSuggestions: true,
                 ghostText: '',
                 suggestions: [{ label: 'test', value: 'test' }],
-                expectedFocusToggle: false,
+                expectedUiToggle: false,
             },
-        ])('$name', async ({ showSuggestions, ghostText, suggestions, expectedFocusToggle, expectedAcceptCall, }) => {
+        ])('$name', async ({ showSuggestions, ghostText, suggestions, expectedUiToggle, expectedAcceptCall, }) => {
             const mockAccept = vi.fn();
             mockedUseCommandCompletion.mockReturnValue({
                 ...mockCommandCompletion,
@@ -2216,17 +2449,20 @@ describe('InputPrompt', () => {
             });
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
                 uiActions,
-                uiState: { activePtyId: 1 },
+                uiState: {},
             });
             await act(async () => {
                 stdin.write('\t');
+                if (expectedUiToggle) {
+                    stdin.write('\t');
+                }
             });
             await waitFor(() => {
-                if (expectedFocusToggle) {
-                    expect(uiActions.setEmbeddedShellFocused).toHaveBeenCalledWith(true);
+                if (expectedUiToggle) {
+                    expect(uiActions.toggleCleanUiDetailsVisible).toHaveBeenCalled();
                 }
                 else {
-                    expect(uiActions.setEmbeddedShellFocused).not.toHaveBeenCalled();
+                    expect(uiActions.toggleCleanUiDetailsVisible).not.toHaveBeenCalled();
                 }
                 if (expectedAcceptCall) {
                     expect(mockAccept).toHaveBeenCalled();
@@ -2234,6 +2470,84 @@ describe('InputPrompt', () => {
             });
             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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
+                uiActions,
+                uiState: {},
+            });
+            await act(async () => {
+                stdin.write('\t');
+                stdin.write('\t');
+            });
+            await waitFor(() => {
+                expect(uiActions.toggleCleanUiDetailsVisible).toHaveBeenCalled();
+            });
+            unmount();
+        });
     });
     describe('mouse interaction', () => {
         it.each([
@@ -2354,7 +2668,7 @@ describe('InputPrompt', () => {
                 };
                 return _jsx(InputPrompt, { ...baseProps, buffer: buffer });
             };
-            const { stdin, stdout, unmount, simulateClick } = renderWithProviders(_jsx(TestWrapper, {}), {
+            const { stdout, unmount, simulateClick } = renderWithProviders(_jsx(TestWrapper, {}), {
                 mouseEventsEnabled: true,
                 useAlternateBuffer: true,
                 uiActions,
@@ -2364,15 +2678,15 @@ describe('InputPrompt', () => {
                 expect(stdout.lastFrame()).toMatchSnapshot();
             });
             // Simulate double-click to expand
-            await simulateClick(stdin, 5, 2);
-            await simulateClick(stdin, 5, 2);
+            await simulateClick(5, 2);
+            await simulateClick(5, 2);
             // 2. Verify expanded content is visible
             await waitFor(() => {
                 expect(stdout.lastFrame()).toMatchSnapshot();
             });
             // Simulate double-click to collapse
-            await simulateClick(stdin, 5, 2);
-            await simulateClick(stdin, 5, 2);
+            await simulateClick(5, 2);
+            await simulateClick(5, 2);
             // 3. Verify placeholder is restored
             await waitFor(() => {
                 expect(stdout.lastFrame()).toMatchSnapshot();
@@ -2424,7 +2738,7 @@ describe('InputPrompt', () => {
                 };
                 return _jsx(InputPrompt, { ...baseProps, buffer: buffer });
             };
-            const { stdin, stdout, unmount, simulateClick } = renderWithProviders(_jsx(TestWrapper, {}), {
+            const { stdout, unmount, simulateClick } = renderWithProviders(_jsx(TestWrapper, {}), {
                 mouseEventsEnabled: true,
                 useAlternateBuffer: true,
                 uiActions,
@@ -2434,8 +2748,8 @@ describe('InputPrompt', () => {
                 expect(stdout.lastFrame()).toContain('line1');
             });
             // Simulate double-click WAY to the right on the first line
-            await simulateClick(stdin, 100, 2);
-            await simulateClick(stdin, 100, 2);
+            await simulateClick(90, 2);
+            await simulateClick(90, 2);
             // Verify it is NOW collapsed
             await waitFor(() => {
                 expect(stdout.lastFrame()).toContain(id);
@@ -2833,6 +3147,445 @@ describe('InputPrompt', () => {
             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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...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 } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
+                settings,
+                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+X hotkey is pressed',
+                input: '\x18',
+            },
+            {
+                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 } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
+                uiState: { shortcutsHelpVisible: true },
+                uiActions: { setShortcutsHelpVisible },
+                mouseEventsEnabled,
+            });
+            await act(async () => {
+                stdin.write(input);
+            });
+            await waitFor(() => {
+                expect(setShortcutsHelpVisible).toHaveBeenCalledWith(false);
+            });
+            unmount();
+        });
+    });
 });
 function clean(str) {
     if (!str)