@machina.ai/cell-cli 1.10.0-rc1 → 1.13.0-rc1

package/dist/src/ui/components/SettingsDialog.test.js

@@ -20,7 +20,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * - Display values for inherited and overridden settings
  *
  */
-import { render } from 'ink-testing-library';
+import { render } from '../../test-utils/render.js';
+import { waitFor } from '../../test-utils/async.js';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { SettingsDialog } from './SettingsDialog.js';
 import { LoadedSettings, SettingScope } from '../../config/settings.js';
@@ -105,147 +106,186 @@ vi.mock('../../utils/settingsUtils.js', async () => {
         saveModifiedSettings: vi.fn(),
     };
 });
-// Helper function to simulate key presses (commented out for now)
-// const simulateKeyPress = async (keyData: Partial<Key> & { name: string }) => {
-//   if (currentKeypressHandler) {
-//     const key: Key = {
-//       ctrl: false,
-//       meta: false,
-//       shift: false,
-//       paste: false,
-//       sequence: keyData.sequence || keyData.name,
-//       ...keyData,
-//     };
-//     currentKeypressHandler(key);
-//     // Allow React to process the state update
-//     await new Promise(resolve => setTimeout(resolve, 10));
-//   }
-// };
-// Mock console.log to avoid noise in tests
-// const originalConsoleLog = console.log;
-// const originalConsoleError = console.error;
+// Shared test schemas
+var StringEnum;
+(function (StringEnum) {
+    StringEnum["FOO"] = "foo";
+    StringEnum["BAR"] = "bar";
+    StringEnum["BAZ"] = "baz";
+})(StringEnum || (StringEnum = {}));
+const ENUM_SETTING = {
+    type: 'enum',
+    label: 'Theme',
+    options: [
+        {
+            label: 'Foo',
+            value: StringEnum.FOO,
+        },
+        {
+            label: 'Bar',
+            value: StringEnum.BAR,
+        },
+        {
+            label: 'Baz',
+            value: StringEnum.BAZ,
+        },
+    ],
+    category: 'UI',
+    requiresRestart: false,
+    default: StringEnum.BAR,
+    description: 'The color theme for the UI.',
+    showInDialog: true,
+};
+const ENUM_FAKE_SCHEMA = {
+    ui: {
+        showInDialog: false,
+        properties: {
+            theme: {
+                ...ENUM_SETTING,
+            },
+        },
+    },
+};
+const TOOLS_SHELL_FAKE_SCHEMA = {
+    tools: {
+        type: 'object',
+        label: 'Tools',
+        category: 'Tools',
+        requiresRestart: false,
+        default: {},
+        description: 'Tool settings.',
+        showInDialog: false,
+        properties: {
+            shell: {
+                type: 'object',
+                label: 'Shell',
+                category: 'Tools',
+                requiresRestart: false,
+                default: {},
+                description: 'Shell tool settings.',
+                showInDialog: false,
+                properties: {
+                    showColor: {
+                        type: 'boolean',
+                        label: 'Show Color',
+                        category: 'Tools',
+                        requiresRestart: false,
+                        default: false,
+                        description: 'Show color in shell output.',
+                        showInDialog: true,
+                    },
+                    enableInteractiveShell: {
+                        type: 'boolean',
+                        label: 'Enable Interactive Shell',
+                        category: 'Tools',
+                        requiresRestart: true,
+                        default: true,
+                        description: 'Enable interactive shell mode.',
+                        showInDialog: true,
+                    },
+                    pager: {
+                        type: 'string',
+                        label: 'Pager',
+                        category: 'Tools',
+                        requiresRestart: false,
+                        default: 'cat',
+                        description: 'The pager command to use for shell output.',
+                        showInDialog: true,
+                    },
+                },
+            },
+        },
+    },
+};
+// Helper function to render SettingsDialog with standard wrapper
+const renderDialog = (settings, onSelect, options) => render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect, onRestartRequest: options?.onRestartRequest, availableTerminalHeight: options?.availableTerminalHeight }) }));
 describe('SettingsDialog', () => {
-    // Simple delay function for remaining tests that need gradual migration
-    const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
-    // Custom waitFor utility for ink testing environment (not compatible with @testing-library/react)
-    const waitFor = async (predicate, options = {}) => {
-        const { timeout = 1000, interval = 10 } = options;
-        const start = Date.now();
-        let lastError;
-        while (Date.now() - start < timeout) {
-            try {
-                predicate();
-                return;
-            }
-            catch (e) {
-                lastError = e;
-            }
-            await new Promise((resolve) => setTimeout(resolve, interval));
-        }
-        if (lastError) {
-            throw lastError;
-        }
-        throw new Error('waitFor timed out');
-    };
     beforeEach(() => {
-        // Reset keypress mock state (variables are commented out)
-        // currentKeypressHandler = null;
-        // isKeypressActive = false;
-        // console.log = vi.fn();
-        // console.error = vi.fn();
         mockToggleVimEnabled.mockResolvedValue(true);
     });
     afterEach(() => {
         TEST_ONLY.clearFlattenedSchema();
         vi.clearAllMocks();
         vi.resetAllMocks();
-        // Reset keypress mock state (variables are commented out)
-        // currentKeypressHandler = null;
-        // isKeypressActive = false;
-        // console.log = originalConsoleLog;
-        // console.error = originalConsoleError;
     });
     describe('Initial Rendering', () => {
         it('should render the settings dialog with default state', () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             const output = lastFrame();
             expect(output).toContain('Settings');
             expect(output).toContain('Apply To');
-            expect(output).toContain('Use Enter to select, Tab to change focus');
+            // Use regex for more flexible help text matching
+            expect(output).toMatch(/Enter.*select.*Esc.*close/);
         });
         it('should accept availableTerminalHeight prop without errors', () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect, availableTerminalHeight: 20 }) }));
+            const { lastFrame } = renderDialog(settings, onSelect, {
+                availableTerminalHeight: 20,
+            });
             const output = lastFrame();
             // Should still render properly with the height prop
             expect(output).toContain('Settings');
-            expect(output).toContain('Use Enter to select');
-        });
-        it('should show settings list with default values', () => {
-            const settings = createMockSettings();
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            const output = lastFrame();
-            // Should show some default settings
-            expect(output).toContain('●'); // Active indicator
+            // Use regex for more flexible help text matching
+            expect(output).toMatch(/Enter.*select.*Esc.*close/);
         });
-        it('should highlight first setting by default', () => {
+        it('should render settings list with visual indicators', () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             const output = lastFrame();
-            // First item should be highlighted with green color and active indicator
-            expect(output).toContain('●');
+            // Use snapshot to capture visual layout including indicators
+            expect(output).toMatchSnapshot();
         });
     });
     describe('Settings Navigation', () => {
-        it('should navigate down with arrow key', async () => {
+        it.each([
+            {
+                name: 'arrow keys',
+                down: TerminalKeys.DOWN_ARROW,
+                up: TerminalKeys.UP_ARROW,
+            },
+            {
+                name: 'vim keys (j/k)',
+                down: 'j',
+                up: 'k',
+            },
+        ])('should navigate with $name', async ({ down, up }) => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount, lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Press down arrow
+            const { stdin, unmount, lastFrame } = renderDialog(settings, onSelect);
+            const initialFrame = lastFrame();
+            expect(initialFrame).toContain('Vim Mode');
+            // Navigate down
             act(() => {
-                stdin.write(TerminalKeys.DOWN_ARROW); // Down arrow
+                stdin.write(down);
+            });
+            await waitFor(() => {
+                expect(lastFrame()).toContain('Disable Auto Update');
+            });
+            // Navigate up
+            act(() => {
+                stdin.write(up);
+            });
+            await waitFor(() => {
+                expect(lastFrame()).toContain('Vim Mode');
             });
-            expect(lastFrame()).toContain('● Disable Auto Update');
-            // The active index should have changed (tested indirectly through behavior)
-            unmount();
-        });
-        it('should navigate up with arrow key', async () => {
-            const settings = createMockSettings();
-            const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // First go down, then up
-            stdin.write(TerminalKeys.DOWN_ARROW); // Down arrow
-            await wait();
-            stdin.write(TerminalKeys.UP_ARROW);
-            await wait();
-            unmount();
-        });
-        it('should navigate with vim keys (j/k)', async () => {
-            const settings = createMockSettings();
-            const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Navigate with vim keys
-            stdin.write('j'); // Down
-            await wait();
-            stdin.write('k'); // Up
-            await wait();
             unmount();
         });
         it('wraps around when at the top of the list', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount, lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount, lastFrame } = renderDialog(settings, onSelect);
             // Try to go up from first item
             act(() => {
                 stdin.write(TerminalKeys.UP_ARROW);
             });
-            await wait();
-            expect(lastFrame()).toContain('● Codebase Investigator Max Num Turns');
+            await waitFor(() => {
+                // Should wrap to last setting (without relying on exact bullet character)
+                expect(lastFrame()).toContain('Codebase Investigator Max Num Turns');
+            });
             unmount();
         });
     });
@@ -254,18 +294,17 @@ describe('SettingsDialog', () => {
             vi.mocked(saveModifiedSettings).mockClear();
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const component = (_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            const { stdin, unmount, lastFrame } = render(component);
+            const { stdin, unmount, lastFrame } = renderDialog(settings, onSelect);
             // Wait for initial render and verify we're on Vim Mode (first setting)
             await waitFor(() => {
-                expect(lastFrame()).toContain('● Vim Mode');
+                expect(lastFrame()).toContain('Vim Mode');
             });
             // Navigate to Disable Auto Update setting and verify we're there
             act(() => {
                 stdin.write(TerminalKeys.DOWN_ARROW);
             });
             await waitFor(() => {
-                expect(lastFrame()).toContain('● Disable Auto Update');
+                expect(lastFrame()).toContain('Disable Auto Update');
             });
             // Toggle the setting
             act(() => {
@@ -279,116 +318,68 @@ describe('SettingsDialog', () => {
             await waitFor(() => {
                 expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalled();
             });
-            expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalledWith(new Set(['general.disableAutoUpdate']), {
-                general: {
+            expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalledWith(new Set(['general.disableAutoUpdate']), expect.objectContaining({
+                general: expect.objectContaining({
                     disableAutoUpdate: true,
-                },
-            }, expect.any(LoadedSettings), SettingScope.User);
+                }),
+            }), expect.any(LoadedSettings), SettingScope.User);
             unmount();
         });
         describe('enum values', () => {
-            let StringEnum;
-            (function (StringEnum) {
-                StringEnum["FOO"] = "foo";
-                StringEnum["BAR"] = "bar";
-                StringEnum["BAZ"] = "baz";
-            })(StringEnum || (StringEnum = {}));
-            const SETTING = {
-                type: 'enum',
-                label: 'Theme',
-                options: [
-                    {
-                        label: 'Foo',
-                        value: StringEnum.FOO,
-                    },
-                    {
-                        label: 'Bar',
-                        value: StringEnum.BAR,
-                    },
-                    {
-                        label: 'Baz',
-                        value: StringEnum.BAZ,
-                    },
-                ],
-                category: 'UI',
-                requiresRestart: false,
-                default: StringEnum.BAR,
-                description: 'The color theme for the UI.',
-                showInDialog: true,
-            };
-            const FAKE_SCHEMA = {
-                ui: {
-                    showInDialog: false,
-                    properties: {
-                        theme: {
-                            ...SETTING,
-                        },
-                    },
+            it.each([
+                {
+                    name: 'toggles to next value',
+                    initialValue: undefined,
+                    expectedValue: StringEnum.BAZ,
+                },
+                {
+                    name: 'loops back to first value when at end',
+                    initialValue: StringEnum.BAZ,
+                    expectedValue: StringEnum.FOO,
                 },
-            };
-            it('toggles enum values with the enter key', async () => {
+            ])('$name', async ({ initialValue, expectedValue }) => {
                 vi.mocked(saveModifiedSettings).mockClear();
-                vi.mocked(getSettingsSchema).mockReturnValue(FAKE_SCHEMA);
+                vi.mocked(getSettingsSchema).mockReturnValue(ENUM_FAKE_SCHEMA);
                 const settings = createMockSettings();
+                if (initialValue !== undefined) {
+                    settings.setValue(SettingScope.User, 'ui.theme', initialValue);
+                }
                 const onSelect = vi.fn();
-                const component = (_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-                const { stdin, unmount } = render(component);
-                // Press Enter to toggle current setting
-                stdin.write(TerminalKeys.DOWN_ARROW);
-                await wait();
-                stdin.write(TerminalKeys.ENTER);
-                await wait();
-                await waitFor(() => {
-                    expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalled();
+                const { stdin, unmount } = renderDialog(settings, onSelect);
+                act(() => {
+                    stdin.write(TerminalKeys.DOWN_ARROW);
+                    stdin.write(TerminalKeys.ENTER);
                 });
-                expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalledWith(new Set(['ui.theme']), {
-                    ui: {
-                        theme: StringEnum.BAZ,
-                    },
-                }, expect.any(LoadedSettings), SettingScope.User);
-                unmount();
-            });
-            it('loops back when reaching the end of an enum', async () => {
-                vi.mocked(saveModifiedSettings).mockClear();
-                vi.mocked(getSettingsSchema).mockReturnValue(FAKE_SCHEMA);
-                const settings = createMockSettings();
-                settings.setValue(SettingScope.User, 'ui.theme', StringEnum.BAZ);
-                const onSelect = vi.fn();
-                const component = (_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-                const { stdin, unmount } = render(component);
-                // Press Enter to toggle current setting
-                stdin.write(TerminalKeys.DOWN_ARROW);
-                await wait();
-                stdin.write(TerminalKeys.ENTER);
-                await wait();
                 await waitFor(() => {
                     expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalled();
                 });
-                expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalledWith(new Set(['ui.theme']), {
-                    ui: {
-                        theme: StringEnum.FOO,
-                    },
-                }, expect.any(LoadedSettings), SettingScope.User);
+                expect(vi.mocked(saveModifiedSettings)).toHaveBeenCalledWith(new Set(['ui.theme']), expect.objectContaining({
+                    ui: expect.objectContaining({
+                        theme: expectedValue,
+                    }),
+                }), expect.any(LoadedSettings), SettingScope.User);
                 unmount();
             });
         });
         it('should toggle setting with Space key', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Press Space to toggle current setting
-            stdin.write(' '); // Space key
-            await wait();
+            act(() => {
+                stdin.write(' '); // Space key
+            });
             unmount();
         });
         it('should handle vim mode setting specially', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Navigate to vim mode setting and toggle it
             // This would require knowing the exact position, so we'll just test that the mock is called
-            stdin.write(TerminalKeys.ENTER); // Enter key
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.ENTER); // Enter key
+            });
             // The mock should potentially be called if vim mode was toggled
             unmount();
         });
@@ -397,26 +388,26 @@ describe('SettingsDialog', () => {
         it('should switch between scopes', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Switch to scope focus
-            stdin.write(TerminalKeys.TAB); // Tab key
-            await wait();
-            // Select different scope (numbers 1-3 typically available)
-            stdin.write('2'); // Select second scope option
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.TAB); // Tab key
+                // Select different scope (numbers 1-3 typically available)
+                stdin.write('2'); // Select second scope option
+            });
             unmount();
         });
         it('should reset to settings focus when scope is selected', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame, unmount } = renderDialog(settings, onSelect);
             // Wait for initial render
             await waitFor(() => {
                 expect(lastFrame()).toContain('Vim Mode');
             });
             // The UI should show the settings section is active and scope section is inactive
-            expect(lastFrame()).toContain('● Vim Mode'); // Settings section active
-            expect(lastFrame()).toContain('  Apply To'); // Scope section inactive
+            expect(lastFrame()).toContain('Vim Mode'); // Settings section active
+            expect(lastFrame()).toContain('Apply To'); // Scope section (don't rely on exact spacing)
             // This test validates the initial state - scope selection behavior
             // is complex due to keypress handling, so we focus on state validation
             unmount();
@@ -426,19 +417,23 @@ describe('SettingsDialog', () => {
         it('should show restart prompt for restart-required settings', async () => {
             const settings = createMockSettings();
             const onRestartRequest = vi.fn();
-            const { unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: () => { }, onRestartRequest: onRestartRequest }) }));
+            const { unmount } = renderDialog(settings, vi.fn(), {
+                onRestartRequest,
+            });
             // This test would need to trigger a restart-required setting change
             // The exact steps depend on which settings require restart
-            await wait();
             unmount();
         });
         it('should handle restart request when r is pressed', async () => {
             const settings = createMockSettings();
             const onRestartRequest = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: () => { }, onRestartRequest: onRestartRequest }) }));
+            const { stdin, unmount } = renderDialog(settings, vi.fn(), {
+                onRestartRequest,
+            });
             // Press 'r' key (this would only work if restart prompt is showing)
-            stdin.write('r');
-            await wait();
+            act(() => {
+                stdin.write('r');
+            });
             // If restart prompt was showing, onRestartRequest should be called
             unmount();
         });
@@ -447,7 +442,7 @@ describe('SettingsDialog', () => {
         it('should call onSelect with undefined when Escape is pressed', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame, unmount } = renderDialog(settings, onSelect);
             // Wait for initial render
             await waitFor(() => {
                 expect(lastFrame()).toContain('Hide Window Title');
@@ -464,13 +459,12 @@ describe('SettingsDialog', () => {
         it('should persist settings across scope changes', async () => {
             const settings = createMockSettings({ vimMode: true });
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Switch to scope selector
-            stdin.write(TerminalKeys.TAB); // Tab
-            await wait();
-            // Change scope
-            stdin.write('2'); // Select workspace scope
-            await wait();
+            const { stdin, unmount } = renderDialog(settings, onSelect);
+            // Switch to scope selector and change scope
+            act(() => {
+                stdin.write(TerminalKeys.TAB); // Tab
+                stdin.write('2'); // Select workspace scope
+            });
             // Settings should be reloaded for new scope
             unmount();
         });
@@ -479,7 +473,7 @@ describe('SettingsDialog', () => {
             { vimMode: false }, // System settings
             { autoUpdate: false });
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             // Should show user scope values initially
             const output = lastFrame();
             expect(output).toContain('Settings');
@@ -490,10 +484,11 @@ describe('SettingsDialog', () => {
             mockToggleVimEnabled.mockRejectedValue(new Error('Toggle failed'));
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Try to toggle a setting (this might trigger vim mode toggle)
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.ENTER); // Enter
+            });
             // Should not crash
             unmount();
         });
@@ -502,27 +497,26 @@ describe('SettingsDialog', () => {
         it('should track modified settings correctly', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Toggle a setting
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
-            // Toggle another setting
-            stdin.write(TerminalKeys.DOWN_ARROW); // Down
-            await wait();
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
+            const { stdin, unmount } = renderDialog(settings, onSelect);
+            // Toggle a setting, then toggle another setting
+            act(() => {
+                stdin.write(TerminalKeys.ENTER); // Enter
+                stdin.write(TerminalKeys.DOWN_ARROW); // Down
+                stdin.write(TerminalKeys.ENTER); // Enter
+            });
             // Should track multiple modified settings
             unmount();
         });
         it('should handle scrolling when there are many settings', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Navigate down many times to test scrolling
-            for (let i = 0; i < 10; i++) {
-                stdin.write(TerminalKeys.DOWN_ARROW); // Down arrow
-                await wait(10);
-            }
+            act(() => {
+                for (let i = 0; i < 10; i++) {
+                    stdin.write(TerminalKeys.DOWN_ARROW); // Down arrow
+                }
+            });
             unmount();
         });
     });
@@ -533,8 +527,9 @@ describe('SettingsDialog', () => {
             const { stdin, unmount } = render(_jsx(VimModeProvider, { settings: settings, children: _jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }) }));
             // Navigate to and toggle vim mode setting
             // This would require knowing the exact position of vim mode setting
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.ENTER); // Enter
+            });
             unmount();
         });
     });
@@ -544,7 +539,7 @@ describe('SettingsDialog', () => {
             { hideWindowTitle: true }, // System settings
             { ideMode: false });
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             const output = lastFrame();
             // Should contain settings labels
             expect(output).toContain('Settings');
@@ -552,28 +547,30 @@ describe('SettingsDialog', () => {
         it('should handle immediate settings save for non-restart-required settings', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Toggle a non-restart-required setting (like hideTips)
-            stdin.write(TerminalKeys.ENTER); // Enter - toggle current setting
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.ENTER); // Enter - toggle current setting
+            });
             // Should save immediately without showing restart prompt
             unmount();
         });
         it('should show restart prompt for restart-required settings', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame, unmount } = renderDialog(settings, onSelect);
             // This test would need to navigate to a specific restart-required setting
             // Since we can't easily target specific settings, we test the general behavior
-            await wait();
             // Should not show restart prompt initially
-            expect(lastFrame()).not.toContain('To see changes, Gemini CLI must be restarted');
+            await waitFor(() => {
+                expect(lastFrame()).not.toContain('To see changes, Gemini CLI must be restarted');
+            });
             unmount();
         });
         it('should clear restart prompt when switching scopes', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { unmount } = renderDialog(settings, onSelect);
             // Restart prompt should be cleared when switching scopes
             unmount();
         });
@@ -583,7 +580,7 @@ describe('SettingsDialog', () => {
             const settings = createMockSettings({}, { vimMode: true, hideWindowTitle: false }, // System settings
             {});
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             const output = lastFrame();
             // Settings should show inherited values
             expect(output).toContain('Settings');
@@ -593,68 +590,122 @@ describe('SettingsDialog', () => {
             { vimMode: true }, // System default
             {});
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             const output = lastFrame();
             // Should show settings with override indicators
             expect(output).toContain('Settings');
         });
     });
+    describe('Race Condition Regression Tests', () => {
+        it.each([
+            {
+                name: 'not reset sibling settings when toggling a nested setting multiple times',
+                toggleCount: 5,
+                shellSettings: {
+                    showColor: false,
+                    enableInteractiveShell: true,
+                },
+                expectedSiblings: {
+                    enableInteractiveShell: true,
+                },
+            },
+            {
+                name: 'preserve multiple sibling settings in nested objects during rapid toggles',
+                toggleCount: 3,
+                shellSettings: {
+                    showColor: false,
+                    enableInteractiveShell: true,
+                    pager: 'less',
+                },
+                expectedSiblings: {
+                    enableInteractiveShell: true,
+                    pager: 'less',
+                },
+            },
+        ])('should $name', async ({ toggleCount, shellSettings, expectedSiblings }) => {
+            vi.mocked(saveModifiedSettings).mockClear();
+            vi.mocked(getSettingsSchema).mockReturnValue(TOOLS_SHELL_FAKE_SCHEMA);
+            const settings = createMockSettings({
+                tools: {
+                    shell: shellSettings,
+                },
+            });
+            const onSelect = vi.fn();
+            const { stdin, unmount } = renderDialog(settings, onSelect);
+            for (let i = 0; i < toggleCount; i++) {
+                act(() => {
+                    stdin.write(TerminalKeys.ENTER);
+                });
+            }
+            await waitFor(() => {
+                expect(vi.mocked(saveModifiedSettings).mock.calls.length).toBeGreaterThan(0);
+            });
+            const calls = vi.mocked(saveModifiedSettings).mock.calls;
+            calls.forEach((call) => {
+                const [modifiedKeys, pendingSettings] = call;
+                if (modifiedKeys.has('tools.shell.showColor')) {
+                    const shellSettings = pendingSettings.tools?.shell;
+                    Object.entries(expectedSiblings).forEach(([key, value]) => {
+                        expect(shellSettings?.[key]).toBe(value);
+                        expect(modifiedKeys.has(`tools.shell.${key}`)).toBe(false);
+                    });
+                    expect(modifiedKeys.size).toBe(1);
+                }
+            });
+            expect(calls.length).toBeGreaterThan(0);
+            unmount();
+        });
+    });
     describe('Keyboard Shortcuts Edge Cases', () => {
         it('should handle rapid key presses gracefully', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Rapid navigation
-            for (let i = 0; i < 5; i++) {
-                stdin.write(TerminalKeys.DOWN_ARROW);
-                stdin.write(TerminalKeys.UP_ARROW);
-            }
-            await wait(100);
+            act(() => {
+                for (let i = 0; i < 5; i++) {
+                    stdin.write(TerminalKeys.DOWN_ARROW);
+                    stdin.write(TerminalKeys.UP_ARROW);
+                }
+            });
             // Should not crash
             unmount();
         });
-        it('should handle Ctrl+C to reset current setting to default', async () => {
-            const settings = createMockSettings({ vimMode: true }); // Start with vimMode enabled
-            const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Press Ctrl+C to reset current setting to default
-            stdin.write('\u0003'); // Ctrl+C
-            await wait();
-            // Should reset the current setting to its default value
-            unmount();
-        });
-        it('should handle Ctrl+L to reset current setting to default', async () => {
-            const settings = createMockSettings({ vimMode: true }); // Start with vimMode enabled
+        it.each([
+            { key: 'Ctrl+C', code: '\u0003' },
+            { key: 'Ctrl+L', code: '\u000C' },
+        ])('should handle $key to reset current setting to default', async ({ code }) => {
+            const settings = createMockSettings({ vimMode: true });
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Press Ctrl+L to reset current setting to default
-            stdin.write('\u000C'); // Ctrl+L
-            await wait();
+            const { stdin, unmount } = renderDialog(settings, onSelect);
+            act(() => {
+                stdin.write(code);
+            });
             // Should reset the current setting to its default value
             unmount();
         });
         it('should handle navigation when only one setting exists', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Try to navigate when potentially at bounds
-            stdin.write(TerminalKeys.DOWN_ARROW);
-            await wait();
-            stdin.write(TerminalKeys.UP_ARROW);
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.DOWN_ARROW);
+                stdin.write(TerminalKeys.UP_ARROW);
+            });
             unmount();
         });
         it('should properly handle Tab navigation between sections', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame, unmount } = renderDialog(settings, onSelect);
             // Wait for initial render
             await waitFor(() => {
                 expect(lastFrame()).toContain('Vim Mode');
             });
             // Verify initial state: settings section active, scope section inactive
-            expect(lastFrame()).toContain('● Vim Mode'); // Settings section active
-            expect(lastFrame()).toContain('  Apply To'); // Scope section inactive
+            expect(lastFrame()).toContain('Vim Mode'); // Settings section active
+            expect(lastFrame()).toContain('Apply To'); // Scope section (don't rely on exact spacing)
             // This test validates the rendered UI structure for tab navigation
             // Actual tab behavior testing is complex due to keypress handling
             unmount();
@@ -666,7 +717,7 @@ describe('SettingsDialog', () => {
             const settings = createMockSettings({ vimMode: null }, // Invalid value
             {}, {});
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             // Should still render without crashing
             expect(lastFrame()).toContain('Settings');
         });
@@ -674,7 +725,7 @@ describe('SettingsDialog', () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
             // Should not crash even if some settings are missing definitions
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame } = renderDialog(settings, onSelect);
             expect(lastFrame()).toContain('Settings');
         });
     });
@@ -682,17 +733,18 @@ describe('SettingsDialog', () => {
         it('should handle complete user workflow: navigate, toggle, change scope, exit', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { lastFrame, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame, unmount } = renderDialog(settings, onSelect);
             // Wait for initial render
             await waitFor(() => {
                 expect(lastFrame()).toContain('Vim Mode');
             });
             // Verify the complete UI is rendered with all necessary sections
             expect(lastFrame()).toContain('Settings'); // Title
-            expect(lastFrame()).toContain('● Vim Mode'); // Active setting
+            expect(lastFrame()).toContain('Vim Mode'); // Active setting
             expect(lastFrame()).toContain('Apply To'); // Scope section
             expect(lastFrame()).toContain('User Settings'); // Scope options (no numbers when settings focused)
-            expect(lastFrame()).toContain('(Use Enter to select, Tab to change focus)'); // Help text
+            // Use regex for more flexible help text matching
+            expect(lastFrame()).toMatch(/Enter.*select.*Tab.*focus.*Esc.*close/);
             // This test validates the complete UI structure is available for user workflow
             // Individual interactions are tested in focused unit tests
             unmount();
@@ -700,20 +752,15 @@ describe('SettingsDialog', () => {
         it('should allow changing multiple settings without losing pending changes', async () => {
             const settings = createMockSettings();
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Toggle first setting (should require restart)
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
-            // Navigate to next setting and toggle it (should not require restart - e.g., vimMode)
-            stdin.write(TerminalKeys.DOWN_ARROW); // Down
-            await wait();
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
-            // Navigate to another setting and toggle it (should also require restart)
-            stdin.write(TerminalKeys.DOWN_ARROW); // Down
-            await wait();
-            stdin.write(TerminalKeys.ENTER); // Enter
-            await wait();
+            const { stdin, unmount } = renderDialog(settings, onSelect);
+            // Toggle multiple settings
+            act(() => {
+                stdin.write(TerminalKeys.ENTER); // Enter
+                stdin.write(TerminalKeys.DOWN_ARROW); // Down
+                stdin.write(TerminalKeys.ENTER); // Enter
+                stdin.write(TerminalKeys.DOWN_ARROW); // Down
+                stdin.write(TerminalKeys.ENTER); // Enter
+            });
             // The test verifies that all changes are preserved and the dialog still works
             // This tests the fix for the bug where changing one setting would reset all pending changes
             unmount();
@@ -721,28 +768,28 @@ describe('SettingsDialog', () => {
         it('should maintain state consistency during complex interactions', async () => {
             const settings = createMockSettings({ vimMode: true });
             const onSelect = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { stdin, unmount } = renderDialog(settings, onSelect);
             // Multiple scope changes
-            stdin.write(TerminalKeys.TAB); // Tab to scope
-            await wait();
-            stdin.write('2'); // Workspace
-            await wait();
-            stdin.write(TerminalKeys.TAB); // Tab to settings
-            await wait();
-            stdin.write(TerminalKeys.TAB); // Tab to scope
-            await wait();
-            stdin.write('1'); // User
-            await wait();
+            act(() => {
+                stdin.write(TerminalKeys.TAB); // Tab to scope
+                stdin.write('2'); // Workspace
+                stdin.write(TerminalKeys.TAB); // Tab to settings
+                stdin.write(TerminalKeys.TAB); // Tab to scope
+                stdin.write('1'); // User
+            });
             // Should maintain consistent state
             unmount();
         });
         it('should handle restart workflow correctly', async () => {
             const settings = createMockSettings();
             const onRestartRequest = vi.fn();
-            const { stdin, unmount } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: () => { }, onRestartRequest: onRestartRequest }) }));
+            const { stdin, unmount } = renderDialog(settings, vi.fn(), {
+                onRestartRequest,
+            });
             // This would test the restart workflow if we could trigger it
-            stdin.write('r'); // Try restart key
-            await wait();
+            act(() => {
+                stdin.write('r'); // Try restart key
+            });
             // Without restart prompt showing, this should have no effect
             expect(onRestartRequest).not.toHaveBeenCalled();
             unmount();
@@ -753,282 +800,244 @@ describe('SettingsDialog', () => {
             let settings = createMockSettings({ 'a.string.setting': 'initial' });
             const onSelect = vi.fn();
             const { stdin, unmount, rerender } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Wait for the dialog to render
-            await wait();
             // Navigate to the last setting
-            for (let i = 0; i < 20; i++) {
-                stdin.write('j'); // Down
-                await wait(10);
-            }
-            // Press Enter to start editing
-            stdin.write('\r');
-            await wait();
-            // Type a new value
-            stdin.write('new value');
-            await wait();
-            // Press Enter to commit
-            stdin.write('\r');
-            await wait();
+            act(() => {
+                for (let i = 0; i < 20; i++) {
+                    stdin.write('j'); // Down
+                }
+            });
+            // Press Enter to start editing, type new value, and commit
+            act(() => {
+                stdin.write('\r'); // Start editing
+                stdin.write('new value');
+                stdin.write('\r'); // Commit
+            });
             settings = createMockSettings({ 'a.string.setting': 'new value' }, {}, {});
             rerender(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            await wait();
             // Press Escape to exit
-            stdin.write('\u001B');
-            await wait();
-            expect(onSelect).toHaveBeenCalledWith(undefined, 'User');
+            act(() => {
+                stdin.write('\u001B');
+            });
+            await waitFor(() => {
+                expect(onSelect).toHaveBeenCalledWith(undefined, 'User');
+            });
             unmount();
         });
     });
     describe('Snapshot Tests', () => {
         /**
          * Snapshot tests for SettingsDialog component using ink-testing-library.
-         * These tests capture the visual output of the component in various states:
-         *
-         * - Default rendering with no custom settings
-         * - Various combinations of boolean settings (enabled/disabled)
-         * - Mixed boolean and number settings configurations
-         * - Different focus states (settings vs scope selector)
-         * - Different scope selections (User, System, Workspace)
-         * - Accessibility settings enabled
-         * - File filtering configurations
-         * - Tools and security settings
-         * - All settings disabled state
-         *
+         * These tests capture the visual output of the component in various states.
          * The snapshots help ensure UI consistency and catch unintended visual changes.
          */
-        it('should render default state correctly', () => {
-            const settings = createMockSettings();
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with various boolean settings enabled', () => {
-            const settings = createMockSettings({
-                general: {
-                    vimMode: true,
-                    disableAutoUpdate: true,
-                    debugKeystrokeLogging: true,
-                    enablePromptCompletion: true,
-                },
-                ui: {
-                    hideWindowTitle: true,
-                    hideTips: true,
-                    showMemoryUsage: true,
-                    showLineNumbers: true,
-                    showCitations: true,
-                    accessibility: {
-                        disableLoadingPhrases: true,
-                        screenReader: true,
+        it.each([
+            {
+                name: 'default state',
+                userSettings: {},
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
+            {
+                name: 'various boolean settings enabled',
+                userSettings: {
+                    general: {
+                        vimMode: true,
+                        disableAutoUpdate: true,
+                        debugKeystrokeLogging: true,
+                        enablePromptCompletion: true,
                     },
-                },
-                ide: {
-                    enabled: true,
-                },
-                context: {
-                    loadMemoryFromIncludeDirectories: true,
-                    fileFiltering: {
-                        respectGitIgnore: true,
-                        respectGeminiIgnore: true,
-                        enableRecursiveFileSearch: true,
-                        disableFuzzySearch: false,
+                    ui: {
+                        hideWindowTitle: true,
+                        hideTips: true,
+                        showMemoryUsage: true,
+                        showLineNumbers: true,
+                        showCitations: true,
+                        accessibility: {
+                            disableLoadingPhrases: true,
+                            screenReader: true,
+                        },
                     },
-                },
-                tools: {
-                    enableInteractiveShell: true,
-                    autoAccept: true,
-                    useRipgrep: true,
-                },
-                security: {
-                    folderTrust: {
+                    ide: {
                         enabled: true,
                     },
+                    context: {
+                        loadMemoryFromIncludeDirectories: true,
+                        fileFiltering: {
+                            respectGitIgnore: true,
+                            respectGeminiIgnore: true,
+                            enableRecursiveFileSearch: true,
+                            disableFuzzySearch: false,
+                        },
+                    },
+                    tools: {
+                        enableInteractiveShell: true,
+                        autoAccept: true,
+                        useRipgrep: true,
+                    },
+                    security: {
+                        folderTrust: {
+                            enabled: true,
+                        },
+                    },
                 },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with mixed boolean and number settings', () => {
-            const settings = createMockSettings({
-                general: {
-                    vimMode: false,
-                    disableAutoUpdate: true,
-                },
-                ui: {
-                    showMemoryUsage: true,
-                    hideWindowTitle: false,
-                },
-                tools: {
-                    truncateToolOutputThreshold: 50000,
-                    truncateToolOutputLines: 1000,
-                },
-                context: {
-                    discoveryMaxDirs: 500,
-                },
-                model: {
-                    maxSessionTurns: 100,
-                    skipNextSpeakerCheck: false,
-                },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render focused on scope selector', () => {
-            const settings = createMockSettings();
-            const onSelect = vi.fn();
-            const { lastFrame, stdin } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Switch focus to scope selector with Tab
-            stdin.write('\t');
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with different scope selected (System)', () => {
-            const settings = createMockSettings({}, // userSettings
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
             {
-                // systemSettings
-                general: {
-                    vimMode: true,
-                    disableAutoUpdate: false,
-                },
-                ui: {
-                    showMemoryUsage: true,
+                name: 'mixed boolean and number settings',
+                userSettings: {
+                    general: {
+                        vimMode: false,
+                        disableAutoUpdate: true,
+                    },
+                    ui: {
+                        showMemoryUsage: true,
+                        hideWindowTitle: false,
+                    },
+                    tools: {
+                        truncateToolOutputThreshold: 50000,
+                        truncateToolOutputLines: 1000,
+                    },
+                    context: {
+                        discoveryMaxDirs: 500,
+                    },
+                    model: {
+                        maxSessionTurns: 100,
+                        skipNextSpeakerCheck: false,
+                    },
                 },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame, stdin } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Switch to scope selector
-            stdin.write('\t');
-            // Navigate to System scope
-            stdin.write('ArrowDown');
-            stdin.write('\r'); // Enter to select
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with different scope selected (Workspace)', () => {
-            const settings = createMockSettings({}, // userSettings
-            {}, // systemSettings
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
             {
-                // workspaceSettings
-                general: {
-                    vimMode: false,
-                    debugKeystrokeLogging: true,
-                },
-                tools: {
-                    useRipgrep: true,
-                    enableInteractiveShell: false,
+                name: 'focused on scope selector',
+                userSettings: {},
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: (stdin) => {
+                    act(() => {
+                        stdin.write('\t');
+                    });
                 },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame, stdin } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            // Switch to scope selector
-            stdin.write('\t');
-            // Navigate to Workspace scope (down twice)
-            stdin.write('ArrowDown');
-            stdin.write('ArrowDown');
-            stdin.write('\r'); // Enter to select
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with accessibility settings enabled', () => {
-            const settings = createMockSettings({
-                ui: {
-                    accessibility: {
-                        disableLoadingPhrases: true,
-                        screenReader: true,
+            },
+            {
+                name: 'accessibility settings enabled',
+                userSettings: {
+                    ui: {
+                        accessibility: {
+                            disableLoadingPhrases: true,
+                            screenReader: true,
+                        },
+                        showMemoryUsage: true,
+                        showLineNumbers: true,
                     },
-                    showMemoryUsage: true,
-                    showLineNumbers: true,
-                },
-                general: {
-                    vimMode: true,
-                },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with file filtering settings configured', () => {
-            const settings = createMockSettings({
-                context: {
-                    fileFiltering: {
-                        respectGitIgnore: false,
-                        respectGeminiIgnore: true,
-                        enableRecursiveFileSearch: false,
-                        disableFuzzySearch: true,
+                    general: {
+                        vimMode: true,
                     },
-                    loadMemoryFromIncludeDirectories: true,
-                    discoveryMaxDirs: 100,
                 },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with tools and security settings', () => {
-            const settings = createMockSettings({
-                tools: {
-                    enableInteractiveShell: true,
-                    autoAccept: false,
-                    useRipgrep: true,
-                    truncateToolOutputThreshold: 25000,
-                    truncateToolOutputLines: 500,
-                },
-                security: {
-                    folderTrust: {
-                        enabled: true,
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
+            {
+                name: 'file filtering settings configured',
+                userSettings: {
+                    context: {
+                        fileFiltering: {
+                            respectGitIgnore: false,
+                            respectGeminiIgnore: true,
+                            enableRecursiveFileSearch: false,
+                            disableFuzzySearch: true,
+                        },
+                        loadMemoryFromIncludeDirectories: true,
+                        discoveryMaxDirs: 100,
                     },
                 },
-                model: {
-                    maxSessionTurns: 50,
-                    skipNextSpeakerCheck: true,
-                },
-            });
-            const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
-            expect(lastFrame()).toMatchSnapshot();
-        });
-        it('should render with all boolean settings disabled', () => {
-            const settings = createMockSettings({
-                general: {
-                    vimMode: false,
-                    disableAutoUpdate: false,
-                    debugKeystrokeLogging: false,
-                    enablePromptCompletion: false,
-                },
-                ui: {
-                    hideWindowTitle: false,
-                    hideTips: false,
-                    showMemoryUsage: false,
-                    showLineNumbers: false,
-                    showCitations: false,
-                    accessibility: {
-                        disableLoadingPhrases: false,
-                        screenReader: false,
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
+            {
+                name: 'tools and security settings',
+                userSettings: {
+                    tools: {
+                        enableInteractiveShell: true,
+                        autoAccept: false,
+                        useRipgrep: true,
+                        truncateToolOutputThreshold: 25000,
+                        truncateToolOutputLines: 500,
                     },
-                },
-                ide: {
-                    enabled: false,
-                },
-                context: {
-                    loadMemoryFromIncludeDirectories: false,
-                    fileFiltering: {
-                        respectGitIgnore: false,
-                        respectGeminiIgnore: false,
-                        enableRecursiveFileSearch: false,
-                        disableFuzzySearch: false,
+                    security: {
+                        folderTrust: {
+                            enabled: true,
+                        },
+                    },
+                    model: {
+                        maxSessionTurns: 50,
+                        skipNextSpeakerCheck: true,
                     },
                 },
-                tools: {
-                    enableInteractiveShell: false,
-                    autoAccept: false,
-                    useRipgrep: false,
-                },
-                security: {
-                    folderTrust: {
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
+            {
+                name: 'all boolean settings disabled',
+                userSettings: {
+                    general: {
+                        vimMode: false,
+                        disableAutoUpdate: false,
+                        debugKeystrokeLogging: false,
+                        enablePromptCompletion: false,
+                    },
+                    ui: {
+                        hideWindowTitle: false,
+                        hideTips: false,
+                        showMemoryUsage: false,
+                        showLineNumbers: false,
+                        showCitations: false,
+                        accessibility: {
+                            disableLoadingPhrases: false,
+                            screenReader: false,
+                        },
+                    },
+                    ide: {
                         enabled: false,
                     },
+                    context: {
+                        loadMemoryFromIncludeDirectories: false,
+                        fileFiltering: {
+                            respectGitIgnore: false,
+                            respectGeminiIgnore: false,
+                            enableRecursiveFileSearch: false,
+                            disableFuzzySearch: false,
+                        },
+                    },
+                    tools: {
+                        enableInteractiveShell: false,
+                        autoAccept: false,
+                        useRipgrep: false,
+                    },
+                    security: {
+                        folderTrust: {
+                            enabled: false,
+                        },
+                    },
                 },
-            });
+                systemSettings: {},
+                workspaceSettings: {},
+                stdinActions: undefined,
+            },
+        ])('should render $name correctly', ({ userSettings, systemSettings, workspaceSettings, stdinActions }) => {
+            const settings = createMockSettings(userSettings, systemSettings, workspaceSettings);
             const onSelect = vi.fn();
-            const { lastFrame } = render(_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: _jsx(SettingsDialog, { settings: settings, onSelect: onSelect }) }));
+            const { lastFrame, stdin } = renderDialog(settings, onSelect);
+            if (stdinActions) {
+                stdinActions(stdin);
+            }
             expect(lastFrame()).toMatchSnapshot();
         });
     });