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

package/dist/src/ui/components/messages/ToolGroupMessage.test.js

@@ -6,6 +6,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { renderWithProviders } from '../../../test-utils/render.js';
 import { describe, it, expect, vi, afterEach } from 'vitest';
+import { act } from 'react';
 import { ToolGroupMessage } from './ToolGroupMessage.js';
 import { Scrollable } from '../shared/Scrollable.js';
 import { makeFakeConfig, CoreToolCallStatus, ApprovalMode, ASK_USER_DISPLAY_NAME, WRITE_FILE_DISPLAY_NAME, EDIT_DISPLAY_NAME, READ_FILE_DISPLAY_NAME, GLOB_DISPLAY_NAME, } from '@google/gemini-cli-core';
@@ -25,9 +26,13 @@ describe('<ToolGroupMessage />', () => {
         ...overrides,
     });
     const baseProps = {
-        groupId: 1,
         terminalWidth: 80,
     };
+    const createItem = (tools) => ({
+        id: 1,
+        type: 'tool_group',
+        tools,
+    });
     const baseMockConfig = makeFakeConfig({
         model: 'gemini-pro',
         targetDir: os.tmpdir(),
@@ -37,18 +42,25 @@ describe('<ToolGroupMessage />', () => {
         enableInteractiveShell: true,
     });
     describe('Golden Snapshots', () => {
-        it('renders single successful tool call', () => {
+        it('renders single successful tool call', async () => {
             const toolCalls = [createToolCall()];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('hides confirming tools (standard behavior)', () => {
+        it('hides confirming tools (standard behavior)', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'confirm-tool',
@@ -60,12 +72,14 @@ describe('<ToolGroupMessage />', () => {
                     },
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), { config: baseMockConfig });
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), { config: baseMockConfig });
             // Should render nothing because all tools in the group are confirming
-            expect(lastFrame()).toBe('');
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toBe('');
             unmount();
         });
-        it('renders multiple tool calls with different statuses (only visible ones)', () => {
+        it('renders multiple tool calls with different statuses (only visible ones)', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'tool-1',
@@ -86,13 +100,20 @@ describe('<ToolGroupMessage />', () => {
                     status: CoreToolCallStatus.Error,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
             // pending-tool should be hidden
+            await waitUntilReady();
             const output = lastFrame();
             expect(output).toContain('successful-tool');
             expect(output).not.toContain('pending-tool');
@@ -100,7 +121,7 @@ describe('<ToolGroupMessage />', () => {
             expect(output).toMatchSnapshot();
             unmount();
         });
-        it('renders mixed tool calls including shell command', () => {
+        it('renders mixed tool calls including shell command', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'tool-1',
@@ -121,13 +142,20 @@ describe('<ToolGroupMessage />', () => {
                     status: CoreToolCallStatus.Scheduled,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
             // write_file (Pending) should be hidden
+            await waitUntilReady();
             const output = lastFrame();
             expect(output).toContain('read_file');
             expect(output).toContain('run_shell_command');
@@ -135,7 +163,7 @@ describe('<ToolGroupMessage />', () => {
             expect(output).toMatchSnapshot();
             unmount();
         });
-        it('renders with limited terminal height', () => {
+        it('renders with limited terminal height', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'tool-1',
@@ -150,42 +178,64 @@ describe('<ToolGroupMessage />', () => {
                     resultDisplay: 'More output here',
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls, availableTerminalHeight: 10 }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls, availableTerminalHeight: 10 }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('renders with narrow terminal width', () => {
+        it('renders with narrow terminal width', async () => {
             const toolCalls = [
                 createToolCall({
                     name: 'very-long-tool-name-that-might-wrap',
                     description: 'This is a very long description that might cause wrapping issues',
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls, terminalWidth: 40 }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls, terminalWidth: 40 }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('renders empty tool calls array', () => {
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: [] }), {
+        it('renders empty tool calls array', async () => {
+            const toolCalls = [];
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: [] }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: [],
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('renders header when scrolled', () => {
+        it('renders header when scrolled', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: '1',
@@ -200,16 +250,23 @@ describe('<ToolGroupMessage />', () => {
                     resultDisplay: 'line1\nline2',
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(Scrollable, { height: 10, hasFocus: true, scrollToBottom: true, children: _jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }) }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(Scrollable, { height: 10, hasFocus: true, scrollToBottom: true, children: _jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }) }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('renders tool call with outputFile', () => {
+        it('renders tool call with outputFile', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'tool-output-file',
@@ -219,16 +276,23 @@ describe('<ToolGroupMessage />', () => {
                     outputFile: '/path/to/output.txt',
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('renders two tool groups where only the last line of the previous group is visible', () => {
+        it('renders two tool groups where only the last line of the previous group is visible', async () => {
             const toolCalls1 = [
                 createToolCall({
                     callId: '1',
@@ -237,6 +301,7 @@ describe('<ToolGroupMessage />', () => {
                     resultDisplay: 'line1\nline2\nline3\nline4\nline5',
                 }),
             ];
+            const item1 = createItem(toolCalls1);
             const toolCalls2 = [
                 createToolCall({
                     callId: '2',
@@ -245,37 +310,52 @@ describe('<ToolGroupMessage />', () => {
                     resultDisplay: 'line1',
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsxs(Scrollable, { height: 6, hasFocus: true, scrollToBottom: true, children: [_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls1 }), _jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls2 })] }), {
+            const item2 = createItem(toolCalls2);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsxs(Scrollable, { height: 6, hasFocus: true, scrollToBottom: true, children: [_jsx(ToolGroupMessage, { ...baseProps, item: item1, toolCalls: toolCalls1 }), _jsx(ToolGroupMessage, { ...baseProps, item: item2, toolCalls: toolCalls2 })] }), {
                 config: baseMockConfig,
                 uiState: {
                     pendingHistoryItems: [
-                        { type: 'tool_group', tools: toolCalls1 },
-                        { type: 'tool_group', tools: toolCalls2 },
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls1,
+                        },
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls2,
+                        },
                     ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
     });
     describe('Border Color Logic', () => {
-        it('uses yellow border for shell commands even when successful', () => {
+        it('uses yellow border for shell commands even when successful', async () => {
             const toolCalls = [
                 createToolCall({
                     name: 'run_shell_command',
                     status: CoreToolCallStatus.Success,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('uses gray border when all tools are successful and no shell commands', () => {
+        it('uses gray border when all tools are successful and no shell commands', async () => {
             const toolCalls = [
                 createToolCall({ status: CoreToolCallStatus.Success }),
                 createToolCall({
@@ -284,18 +364,25 @@ describe('<ToolGroupMessage />', () => {
                     status: CoreToolCallStatus.Success,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
     });
     describe('Height Calculation', () => {
-        it('calculates available height correctly with multiple tools with results', () => {
+        it('calculates available height correctly with multiple tools with results', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'tool-1',
@@ -310,13 +397,20 @@ describe('<ToolGroupMessage />', () => {
                     resultDisplay: '', // No result
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls, availableTerminalHeight: 20 }), {
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls, availableTerminalHeight: 20 }), {
                 config: baseMockConfig,
                 uiState: {
-                    pendingHistoryItems: [{ type: 'tool_group', tools: toolCalls }],
+                    pendingHistoryItems: [
+                        {
+                            type: 'tool_group',
+                            tools: toolCalls,
+                        },
+                    ],
                 },
             });
-            expect(lastFrame()).toMatchSnapshot();
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
     });
@@ -348,7 +442,7 @@ describe('<ToolGroupMessage />', () => {
                 resultDisplay: 'error message',
                 shouldHide: false,
             },
-        ])('filtering logic for status=$status and hasResult=$resultDisplay', ({ status, resultDisplay, shouldHide }) => {
+        ])('filtering logic for status=$status and hasResult=$resultDisplay', async ({ status, resultDisplay, shouldHide }) => {
             const toolCalls = [
                 createToolCall({
                     callId: `ask-user-${status}`,
@@ -357,16 +451,18 @@ describe('<ToolGroupMessage />', () => {
                     resultDisplay,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), { config: baseMockConfig });
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), { config: baseMockConfig });
+            await waitUntilReady();
             if (shouldHide) {
-                expect(lastFrame()).toBe('');
+                expect(lastFrame({ allowEmpty: true })).toBe('');
             }
             else {
                 expect(lastFrame()).toMatchSnapshot();
             }
             unmount();
         });
-        it('shows other tools when ask_user is filtered out', () => {
+        it('shows other tools when ask_user is filtered out', async () => {
             const toolCalls = [
                 createToolCall({
                     callId: 'other-tool',
@@ -379,11 +475,13 @@ describe('<ToolGroupMessage />', () => {
                     status: CoreToolCallStatus.Scheduled,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), { config: baseMockConfig });
-            expect(lastFrame()).toMatchSnapshot();
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), { config: baseMockConfig });
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toMatchSnapshot();
             unmount();
         });
-        it('renders nothing when only tool is in-progress AskUser with borderBottom=false', () => {
+        it('renders nothing when only tool is in-progress AskUser with borderBottom=false', async () => {
             // AskUser tools in progress are rendered by AskUserDialog, not ToolGroupMessage.
             // When AskUser is the only tool and borderBottom=false (no border to close),
             // the component should render nothing.
@@ -394,9 +492,11 @@ describe('<ToolGroupMessage />', () => {
                     status: CoreToolCallStatus.Executing,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls, borderBottom: false }), { config: baseMockConfig });
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls, borderBottom: false }), { config: baseMockConfig });
             // AskUser tools in progress are rendered by AskUserDialog, so we expect nothing.
-            expect(lastFrame()).toBe('');
+            await waitUntilReady();
+            expect(lastFrame({ allowEmpty: true })).toBe('');
             unmount();
         });
     });
@@ -415,7 +515,7 @@ describe('<ToolGroupMessage />', () => {
             },
             { name: READ_FILE_DISPLAY_NAME, mode: ApprovalMode.PLAN, visible: true },
             { name: GLOB_DISPLAY_NAME, mode: ApprovalMode.PLAN, visible: true },
-        ])('filtering logic for $name in $mode mode', ({ name, mode, visible }) => {
+        ])('filtering logic for $name in $mode mode', async ({ name, mode, visible }) => {
             const toolCalls = [
                 createToolCall({
                     callId: 'test-call',
@@ -423,15 +523,138 @@ describe('<ToolGroupMessage />', () => {
                     approvalMode: mode,
                 }),
             ];
-            const { lastFrame, unmount } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, toolCalls: toolCalls }), { config: baseMockConfig });
+            const item = createItem(toolCalls);
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: item, toolCalls: toolCalls }), { config: baseMockConfig });
+            await waitUntilReady();
             if (visible) {
                 expect(lastFrame()).toContain(name);
             }
             else {
-                expect(lastFrame()).toBe('');
+                expect(lastFrame({ allowEmpty: true })).toBe('');
             }
             unmount();
         });
     });
+    describe('Manual Overflow Detection', () => {
+        it('detects overflow for string results exceeding available height', async () => {
+            const toolCalls = [
+                createToolCall({
+                    resultDisplay: 'line 1\nline 2\nline 3\nline 4\nline 5',
+                }),
+            ];
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: { id: 1, type: 'tool_group', tools: toolCalls }, toolCalls: toolCalls, availableTerminalHeight: 6, isExpandable: true }), {
+                config: baseMockConfig,
+                useAlternateBuffer: true,
+                uiState: {
+                    constrainHeight: true,
+                },
+            });
+            await waitUntilReady();
+            expect(lastFrame()?.toLowerCase()).toContain('press ctrl+o to show more lines');
+            unmount();
+        });
+        it('detects overflow for array results exceeding available height', async () => {
+            // resultDisplay when array is expected to be AnsiLine[]
+            // AnsiLine is AnsiToken[]
+            const toolCalls = [
+                createToolCall({
+                    resultDisplay: Array(5).fill([{ text: 'line', fg: 'default' }]),
+                }),
+            ];
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: { id: 1, type: 'tool_group', tools: toolCalls }, toolCalls: toolCalls, availableTerminalHeight: 6, isExpandable: true }), {
+                config: baseMockConfig,
+                useAlternateBuffer: true,
+                uiState: {
+                    constrainHeight: true,
+                },
+            });
+            await waitUntilReady();
+            expect(lastFrame()?.toLowerCase()).toContain('press ctrl+o to show more lines');
+            unmount();
+        });
+        it('respects ACTIVE_SHELL_MAX_LINES for focused shell tools', async () => {
+            const toolCalls = [
+                createToolCall({
+                    name: 'run_shell_command',
+                    status: CoreToolCallStatus.Executing,
+                    ptyId: 1,
+                    resultDisplay: Array(20).fill('line').join('\n'), // 20 lines > 15 (limit)
+                }),
+            ];
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: { id: 1, type: 'tool_group', tools: toolCalls }, toolCalls: toolCalls, availableTerminalHeight: 100, isExpandable: true }), {
+                config: baseMockConfig,
+                useAlternateBuffer: true,
+                uiState: {
+                    constrainHeight: true,
+                    activePtyId: 1,
+                    embeddedShellFocused: true,
+                },
+            });
+            await waitUntilReady();
+            expect(lastFrame()?.toLowerCase()).toContain('press ctrl+o to show more lines');
+            unmount();
+        });
+        it('does not show expansion hint when content is within limits', async () => {
+            const toolCalls = [
+                createToolCall({
+                    resultDisplay: 'small result',
+                }),
+            ];
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: { id: 1, type: 'tool_group', tools: toolCalls }, toolCalls: toolCalls, availableTerminalHeight: 20, isExpandable: true }), {
+                config: baseMockConfig,
+                useAlternateBuffer: true,
+                uiState: {
+                    constrainHeight: true,
+                },
+            });
+            await waitUntilReady();
+            expect(lastFrame()).not.toContain('Press Ctrl+O to show more lines');
+            unmount();
+        });
+        it('hides expansion hint when constrainHeight is false', async () => {
+            const toolCalls = [
+                createToolCall({
+                    resultDisplay: 'line 1\nline 2\nline 3\nline 4\nline 5',
+                }),
+            ];
+            const { lastFrame, unmount, waitUntilReady } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: { id: 1, type: 'tool_group', tools: toolCalls }, toolCalls: toolCalls, availableTerminalHeight: 6, isExpandable: true }), {
+                config: baseMockConfig,
+                useAlternateBuffer: true,
+                uiState: {
+                    constrainHeight: false,
+                },
+            });
+            await waitUntilReady();
+            expect(lastFrame()).not.toContain('Press Ctrl+O to show more lines');
+            unmount();
+        });
+        it('isolates overflow hint in ASB mode (ignores global overflow state)', async () => {
+            // In this test, the tool output is SHORT (no local overflow).
+            // We will inject a dummy ID into the global overflow state.
+            // ToolGroupMessage should still NOT show the hint because it calculates
+            // overflow locally and passes it as a prop.
+            const toolCalls = [
+                createToolCall({
+                    resultDisplay: 'short result',
+                }),
+            ];
+            const { lastFrame, unmount, waitUntilReady, capturedOverflowActions } = renderWithProviders(_jsx(ToolGroupMessage, { ...baseProps, item: { id: 1, type: 'tool_group', tools: toolCalls }, toolCalls: toolCalls, availableTerminalHeight: 100, isExpandable: true }), {
+                config: baseMockConfig,
+                useAlternateBuffer: true,
+                uiState: {
+                    constrainHeight: true,
+                },
+            });
+            await waitUntilReady();
+            // Manually trigger a global overflow
+            act(() => {
+                expect(capturedOverflowActions).toBeDefined();
+                capturedOverflowActions.addOverflowingId('unrelated-global-id');
+            });
+            // The hint should NOT appear because ToolGroupMessage is isolated by its prop logic
+            expect(lastFrame()).not.toContain('Press Ctrl+O to show more lines');
+            unmount();
+        });
+    });
 });
 //# sourceMappingURL=ToolGroupMessage.test.js.map