@google/gemini-cli 0.25.0-preview.0 → 0.26.0-nightly.20260119.20580d754

package/dist/src/config/config.test.js

@@ -8,6 +8,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { DEFAULT_FILE_FILTERING_OPTIONS, OutputFormat, SHELL_TOOL_NAME, WRITE_FILE_TOOL_NAME, EDIT_TOOL_NAME, WEB_FETCH_TOOL_NAME, debugLogger, ApprovalMode, } from '@google/gemini-cli-core';
 import { loadCliConfig, parseArguments } from './config.js';
+import { createTestMergedSettings } from './settings.js';
 import * as ServerConfig from '@google/gemini-cli-core';
 import { isWorkspaceTrusted } from './trustedFolders.js';
 import { ExtensionManager } from './extension-manager.js';
@@ -146,7 +147,7 @@ describe('parseArguments', () => {
         const mockConsoleError = vi
             .spyOn(console, 'error')
             .mockImplementation(() => { });
-        await expect(parseArguments({})).rejects.toThrow('process.exit called');
+        await expect(parseArguments(createTestMergedSettings())).rejects.toThrow('process.exit called');
         expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Cannot use both --prompt (-p) and --prompt-interactive (-i) together'));
         mockExit.mockRestore();
         mockConsoleError.mockRestore();
@@ -169,7 +170,7 @@ describe('parseArguments', () => {
         },
     ])('$description', async ({ argv, expected }) => {
         process.argv = argv;
-        const parsedArgs = await parseArguments({});
+        const parsedArgs = await parseArguments(createTestMergedSettings());
         expect(parsedArgs.prompt).toBe(expected.prompt);
         expect(parsedArgs.promptInteractive).toBe(expected.promptInteractive);
     });
@@ -282,7 +283,7 @@ describe('parseArguments', () => {
             },
         ])('$description', async ({ argv, expectedQuery, expectedModel, debug }) => {
             process.argv = argv;
-            const parsedArgs = await parseArguments({});
+            const parsedArgs = await parseArguments(createTestMergedSettings());
             expect(parsedArgs.query).toBe(expectedQuery);
             expect(parsedArgs.prompt).toBe(expectedQuery);
             expect(parsedArgs.promptInteractive).toBeUndefined();
@@ -311,7 +312,7 @@ describe('parseArguments', () => {
         const mockConsoleError = vi
             .spyOn(console, 'error')
             .mockImplementation(() => { });
-        await expect(parseArguments({})).rejects.toThrow('process.exit called');
+        await expect(parseArguments(createTestMergedSettings())).rejects.toThrow('process.exit called');
         expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Cannot use both --yolo (-y) and --approval-mode together. Use --approval-mode=yolo instead.'));
         mockExit.mockRestore();
         mockConsoleError.mockRestore();
@@ -329,7 +330,7 @@ describe('parseArguments', () => {
         },
     ])('$description', async ({ argv, expected }) => {
         process.argv = argv;
-        const parsedArgs = await parseArguments({});
+        const parsedArgs = await parseArguments(createTestMergedSettings());
         expect(parsedArgs.approvalMode).toBe(expected.approvalMode);
         expect(parsedArgs.yolo).toBe(expected.yolo);
     });
@@ -344,7 +345,7 @@ describe('parseArguments', () => {
         const debugErrorSpy = vi
             .spyOn(debugLogger, 'error')
             .mockImplementation(() => { });
-        await expect(parseArguments({})).rejects.toThrow('process.exit called');
+        await expect(parseArguments(createTestMergedSettings())).rejects.toThrow('process.exit called');
         expect(debugErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid values:'));
         expect(mockConsoleError).toHaveBeenCalled();
         mockExit.mockRestore();
@@ -356,7 +357,7 @@ describe('parseArguments', () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '--resume', 'session-id'];
         try {
-            const argv = await parseArguments({});
+            const argv = await parseArguments(createTestMergedSettings());
             expect(argv.resume).toBe('session-id');
         }
         finally {
@@ -368,7 +369,7 @@ describe('parseArguments', () => {
         process.stdin.isTTY = true; // Make it interactive to avoid validation error
         process.argv = ['node', 'script.js', '--resume'];
         try {
-            const argv = await parseArguments({});
+            const argv = await parseArguments(createTestMergedSettings());
             expect(argv.resume).toBe(RESUME_LATEST);
             expect(argv.resume).toBe('latest');
         }
@@ -383,7 +384,7 @@ describe('parseArguments', () => {
             '--allowed-tools',
             'read_file,ShellTool(git status)',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.allowedTools).toEqual(['read_file', 'ShellTool(git status)']);
     });
     it('should support comma-separated values for --allowed-mcp-server-names', async () => {
@@ -393,12 +394,12 @@ describe('parseArguments', () => {
             '--allowed-mcp-server-names',
             'server1,server2',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.allowedMcpServerNames).toEqual(['server1', 'server2']);
     });
     it('should support comma-separated values for --extensions', async () => {
         process.argv = ['node', 'script.js', '--extensions', 'ext1,ext2'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.extensions).toEqual(['ext1', 'ext2']);
     });
     it('should correctly parse positional arguments when flags with arguments are present', async () => {
@@ -409,7 +410,7 @@ describe('parseArguments', () => {
             'test-model-string',
             'my-positional-arg',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.model).toBe('test-model-string');
         expect(argv.query).toBe('my-positional-arg');
     });
@@ -425,7 +426,7 @@ describe('parseArguments', () => {
             '--allowed-tools=ShellTool(wc)',
             'Use whoami to write a poem in file poem.md about my username in pig latin and use wc to tell me how many lines are in the poem you wrote.',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.extensions).toEqual(['none']);
         expect(argv.approvalMode).toBe('auto_edit');
         expect(argv.allowedTools).toEqual([
@@ -473,8 +474,8 @@ describe('loadCliConfig', () => {
         });
         it(`should leave proxy to empty by default`, async () => {
             process.argv = ['node', 'script.js'];
-            const argv = await parseArguments({});
-            const settings = {};
+            const argv = await parseArguments(createTestMergedSettings());
+            const settings = createTestMergedSettings();
             const config = await loadCliConfig(settings, 'test-session', argv);
             expect(config.getProxy()).toBeFalsy();
         });
@@ -513,8 +514,8 @@ describe('loadCliConfig', () => {
             it(`should set proxy to ${expected} according to environment variable [${input.env_name}]`, async () => {
                 vi.stubEnv(input.env_name, input.proxy_url);
                 process.argv = ['node', 'script.js'];
-                const argv = await parseArguments({});
-                const settings = {};
+                const argv = await parseArguments(createTestMergedSettings());
+                const settings = createTestMergedSettings();
                 const config = await loadCliConfig(settings, 'test-session', argv);
                 expect(config.getProxy()).toBe(expected);
             });
@@ -522,8 +523,8 @@ describe('loadCliConfig', () => {
     });
     it('should use default fileFilter options when unconfigured', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFileFilteringRespectGitIgnore()).toBe(DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore);
         expect(config.getFileFilteringRespectGeminiIgnore()).toBe(DEFAULT_FILE_FILTERING_OPTIONS.respectGeminiIgnore);
@@ -541,7 +542,7 @@ describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
     });
     it('should pass extension context file paths to loadServerHierarchicalMemory', async () => {
         process.argv = ['node', 'script.js'];
-        const settings = {};
+        const settings = createTestMergedSettings();
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
@@ -571,23 +572,23 @@ describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
                 isActive: true,
             },
         ]);
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         await loadCliConfig(settings, 'session-id', argv);
-        expect(ServerConfig.loadServerHierarchicalMemory).toHaveBeenCalledWith(expect.any(String), [], false, expect.any(Object), expect.any(ExtensionManager), true, 'tree', {
-            respectGitIgnore: false,
+        expect(ServerConfig.loadServerHierarchicalMemory).toHaveBeenCalledWith(expect.any(String), [], false, expect.any(Object), expect.any(ExtensionManager), true, 'tree', expect.objectContaining({
+            respectGitIgnore: true,
             respectGeminiIgnore: true,
-        }, undefined);
+        }), 200);
     });
 });
 describe('mergeMcpServers', () => {
     it('should not modify the original settings object', async () => {
-        const settings = {
+        const settings = createTestMergedSettings({
             mcpServers: {
                 'test-server': {
                     url: 'http://localhost:8080',
                 },
             },
-        };
+        });
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
@@ -605,7 +606,7 @@ describe('mergeMcpServers', () => {
         ]);
         const originalSettings = JSON.parse(JSON.stringify(settings));
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         await loadCliConfig(settings, 'test-session', argv);
         expect(settings).toEqual(originalSettings);
     });
@@ -626,7 +627,9 @@ describe('mergeExcludeTools', () => {
         process.stdin.isTTY = originalIsTTY;
     });
     it('should merge excludeTools from settings and extensions', async () => {
-        const settings = { tools: { exclude: ['tool1', 'tool2'] } };
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['tool1', 'tool2'] },
+        });
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
@@ -648,13 +651,15 @@ describe('mergeExcludeTools', () => {
             },
         ]);
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(new Set(['tool1', 'tool2', 'tool3', 'tool4', 'tool5']));
         expect(config.getExcludeTools()).toHaveLength(5);
     });
     it('should handle overlapping excludeTools between settings and extensions', async () => {
-        const settings = { tools: { exclude: ['tool1', 'tool2'] } };
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['tool1', 'tool2'] },
+        });
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
@@ -667,13 +672,15 @@ describe('mergeExcludeTools', () => {
             },
         ]);
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(new Set(['tool1', 'tool2', 'tool3']));
         expect(config.getExcludeTools()).toHaveLength(3);
     });
     it('should handle overlapping excludeTools between extensions', async () => {
-        const settings = { tools: { exclude: ['tool1'] } };
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['tool1'] },
+        });
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
@@ -695,38 +702,40 @@ describe('mergeExcludeTools', () => {
             },
         ]);
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(new Set(['tool1', 'tool2', 'tool3', 'tool4']));
         expect(config.getExcludeTools()).toHaveLength(4);
     });
     it('should return an empty array when no excludeTools are specified and it is interactive', async () => {
         process.stdin.isTTY = true;
-        const settings = {};
+        const settings = createTestMergedSettings();
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(new Set([]));
     });
     it('should return default excludes when no excludeTools are specified and it is not interactive', async () => {
         process.stdin.isTTY = false;
-        const settings = {};
+        const settings = createTestMergedSettings();
         process.argv = ['node', 'script.js', '-p', 'test'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(defaultExcludes);
     });
     it('should handle settings with excludeTools but no extensions', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { tools: { exclude: ['tool1', 'tool2'] } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['tool1', 'tool2'] },
+        });
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(new Set(['tool1', 'tool2']));
         expect(config.getExcludeTools()).toHaveLength(2);
     });
     it('should handle extensions with excludeTools but no settings', async () => {
-        const settings = {};
+        const settings = createTestMergedSettings();
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext',
@@ -739,13 +748,15 @@ describe('mergeExcludeTools', () => {
             },
         ]);
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(new Set(['tool1', 'tool2']));
         expect(config.getExcludeTools()).toHaveLength(2);
     });
     it('should not modify the original settings object', async () => {
-        const settings = { tools: { exclude: ['tool1'] } };
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['tool1'] },
+        });
         vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext',
@@ -759,7 +770,7 @@ describe('mergeExcludeTools', () => {
         ]);
         const originalSettings = JSON.parse(JSON.stringify(settings));
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         await loadCliConfig(settings, 'test-session', argv);
         expect(settings).toEqual(originalSettings);
     });
@@ -779,8 +790,8 @@ describe('Approval mode tool exclusion logic', () => {
     });
     it('should exclude all interactive tools in non-interactive mode with default approval mode', async () => {
         process.argv = ['node', 'script.js', '-p', 'test'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain(SHELL_TOOL_NAME);
@@ -796,8 +807,8 @@ describe('Approval mode tool exclusion logic', () => {
             '-p',
             'test',
         ];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain(SHELL_TOOL_NAME);
@@ -813,8 +824,8 @@ describe('Approval mode tool exclusion logic', () => {
             '-p',
             'test',
         ];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain(SHELL_TOOL_NAME);
@@ -830,18 +841,39 @@ describe('Approval mode tool exclusion logic', () => {
             '-p',
             'test',
         ];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).not.toContain(SHELL_TOOL_NAME);
         expect(excludedTools).not.toContain(EDIT_TOOL_NAME);
         expect(excludedTools).not.toContain(WRITE_FILE_TOOL_NAME);
     });
+    it('should exclude all interactive tools in non-interactive mode with plan approval mode', async () => {
+        process.argv = [
+            'node',
+            'script.js',
+            '--approval-mode',
+            'plan',
+            '-p',
+            'test',
+        ];
+        const settings = createTestMergedSettings({
+            experimental: {
+                plan: true,
+            },
+        });
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        const excludedTools = config.getExcludeTools();
+        expect(excludedTools).toContain(SHELL_TOOL_NAME);
+        expect(excludedTools).toContain(EDIT_TOOL_NAME);
+        expect(excludedTools).toContain(WRITE_FILE_TOOL_NAME);
+    });
     it('should exclude no interactive tools in non-interactive mode with legacy yolo flag', async () => {
         process.argv = ['node', 'script.js', '--yolo', '-p', 'test'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).not.toContain(SHELL_TOOL_NAME);
@@ -859,8 +891,8 @@ describe('Approval mode tool exclusion logic', () => {
         ];
         for (const testCase of testCases) {
             process.argv = testCase.args;
-            const argv = await parseArguments({});
-            const settings = {};
+            const argv = await parseArguments(createTestMergedSettings());
+            const settings = createTestMergedSettings();
             const config = await loadCliConfig(settings, 'test-session', argv);
             const excludedTools = config.getExcludeTools();
             expect(excludedTools).not.toContain(SHELL_TOOL_NAME);
@@ -877,8 +909,10 @@ describe('Approval mode tool exclusion logic', () => {
             '-p',
             'test',
         ];
-        const argv = await parseArguments({});
-        const settings = { tools: { exclude: ['custom_tool'] } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['custom_tool'] },
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain('custom_tool'); // From settings
@@ -888,12 +922,12 @@ describe('Approval mode tool exclusion logic', () => {
     });
     it('should throw an error if YOLO mode is attempted when disableYoloMode is true', async () => {
         process.argv = ['node', 'script.js', '--yolo'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             security: {
                 disableYoloMode: true,
             },
-        };
+        });
         await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
     });
     it('should throw an error for invalid approval mode values in loadCliConfig', async () => {
@@ -904,8 +938,8 @@ describe('Approval mode tool exclusion logic', () => {
             prompt: '',
             yolo: false,
         };
-        const settings = {};
-        await expect(loadCliConfig(settings, 'test-session', invalidArgv)).rejects.toThrow('Invalid approval mode: invalid_mode. Valid values are: yolo, auto_edit, default');
+        const settings = createTestMergedSettings();
+        await expect(loadCliConfig(settings, 'test-session', invalidArgv)).rejects.toThrow('Invalid approval mode: invalid_mode. Valid values are: yolo, auto_edit, plan, default');
     });
 });
 describe('loadCliConfig with allowed-mcp-server-names', () => {
@@ -919,16 +953,16 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
-    const baseSettings = {
+    const baseSettings = createTestMergedSettings({
         mcpServers: {
             server1: { url: 'http://localhost:8080' },
             server2: { url: 'http://localhost:8081' },
             server3: { url: 'http://localhost:8082' },
         },
-    };
+    });
     it('should allow all MCP servers if the flag is not provided', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(baseSettings, 'test-session', argv);
         expect(config.getMcpServers()).toEqual(baseSettings.mcpServers);
     });
@@ -939,7 +973,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             '--allowed-mcp-server-names',
             'server1',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(baseSettings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server1']);
     });
@@ -952,7 +986,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             '--allowed-mcp-server-names',
             'server3',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(baseSettings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server1', 'server3']);
     });
@@ -965,46 +999,46 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             '--allowed-mcp-server-names',
             'server4',
         ];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(baseSettings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server1', 'server4']);
     });
     it('should allow no MCP servers if the flag is provided but empty', async () => {
         process.argv = ['node', 'script.js', '--allowed-mcp-server-names', ''];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(baseSettings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['']);
     });
     it('should read allowMCPServers from settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...baseSettings,
             mcp: { allowed: ['server1', 'server2'] },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server1', 'server2']);
     });
     it('should read excludeMCPServers from settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...baseSettings,
             mcp: { excluded: ['server1', 'server2'] },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getBlockedMcpServers()).toEqual(['server1', 'server2']);
     });
     it('should override allowMCPServers with excludeMCPServers if overlapping', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...baseSettings,
             mcp: {
                 excluded: ['server1'],
                 allowed: ['server1', 'server2'],
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server1', 'server2']);
         expect(config.getBlockedMcpServers()).toEqual(['server1']);
@@ -1016,14 +1050,14 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             '--allowed-mcp-server-names',
             'server1',
         ];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...baseSettings,
             mcp: {
                 excluded: ['server1'],
                 allowed: ['server2'],
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server1']);
     });
@@ -1036,14 +1070,14 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             '--allowed-mcp-server-names',
             'server3',
         ];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...baseSettings,
             mcp: {
                 allowed: ['server1', 'server2'], // Should be ignored
                 excluded: ['server3'], // Should be ignored
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getAllowedMcpServers()).toEqual(['server2', 'server3']);
         expect(config.getBlockedMcpServers()).toEqual([]);
@@ -1058,40 +1092,48 @@ describe('loadCliConfig model selection', () => {
     });
     it('selects a model from settings.json if provided', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({
             model: {
                 name: 'gemini-2.5-pro',
             },
-        }, 'test-session', argv);
+        }), 'test-session', argv);
         expect(config.getModel()).toBe('gemini-2.5-pro');
     });
     it('uses the default gemini model if nothing is set', async () => {
         process.argv = ['node', 'script.js']; // No model set.
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({
         // No model set.
-        }, 'test-session', argv);
+        }), 'test-session', argv);
         expect(config.getModel()).toBe('auto-gemini-2.5');
     });
     it('always prefers model from argv', async () => {
         process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash-preview'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({
             model: {
                 name: 'gemini-2.5-pro',
             },
-        }, 'test-session', argv);
+        }), 'test-session', argv);
         expect(config.getModel()).toBe('gemini-2.5-flash-preview');
     });
     it('selects the model from argv if provided', async () => {
         process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash-preview'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({
         // No model provided via settings.
-        }, 'test-session', argv);
+        }), 'test-session', argv);
         expect(config.getModel()).toBe('gemini-2.5-flash-preview');
     });
+    it('selects the default auto model if provided via auto alias', async () => {
+        process.argv = ['node', 'script.js', '--model', 'auto'];
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({
+        // No model provided via settings.
+        }), 'test-session', argv);
+        expect(config.getModel()).toBe('auto-gemini-2.5');
+    });
 });
 describe('loadCliConfig folderTrust', () => {
     beforeEach(() => {
@@ -1106,34 +1148,34 @@ describe('loadCliConfig folderTrust', () => {
     });
     it('should be false when folderTrust is false', async () => {
         process.argv = ['node', 'script.js'];
-        const settings = {
+        const settings = createTestMergedSettings({
             security: {
                 folderTrust: {
                     enabled: false,
                 },
             },
-        };
-        const argv = await parseArguments({});
+        });
+        const argv = await parseArguments(createTestMergedSettings());
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFolderTrust()).toBe(false);
     });
     it('should be true when folderTrust is true', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             security: {
                 folderTrust: {
                     enabled: true,
                 },
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFolderTrust()).toBe(true);
     });
     it('should be false by default', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFolderTrust()).toBe(false);
     });
@@ -1157,8 +1199,8 @@ describe('loadCliConfig with includeDirectories', () => {
             '--include-directories',
             `${path.resolve(path.sep, 'cli', 'path1')},${path.join(mockCwd, 'cli', 'path2')}`,
         ];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             context: {
                 includeDirectories: [
                     path.resolve(path.sep, 'settings', 'path1'),
@@ -1166,7 +1208,7 @@ describe('loadCliConfig with includeDirectories', () => {
                     path.join(mockCwd, 'settings', 'path3'),
                 ],
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         const expected = [
             mockCwd,
@@ -1195,21 +1237,21 @@ describe('loadCliConfig compressionThreshold', () => {
     });
     it('should pass settings to the core config', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             model: {
                 compressionThreshold: 0.5,
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(await config.getCompressionThreshold()).toBe(0.5);
     });
-    it('should have undefined compressionThreshold if not in settings', async () => {
+    it('should have default compressionThreshold if not in settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
-        expect(await config.getCompressionThreshold()).toBeUndefined();
+        expect(await config.getCompressionThreshold()).toBe(0.5);
     });
 });
 describe('loadCliConfig useRipgrep', () => {
@@ -1225,22 +1267,22 @@ describe('loadCliConfig useRipgrep', () => {
     });
     it('should be true by default when useRipgrep is not set in settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getUseRipgrep()).toBe(true);
     });
     it('should be false when useRipgrep is set to false in settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { tools: { useRipgrep: false } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({ tools: { useRipgrep: false } });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getUseRipgrep()).toBe(false);
     });
     it('should be true when useRipgrep is explicitly set to true in settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { tools: { useRipgrep: true } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({ tools: { useRipgrep: true } });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getUseRipgrep()).toBe(true);
     });
@@ -1258,35 +1300,35 @@ describe('screenReader configuration', () => {
     });
     it('should use screenReader value from settings if CLI flag is not present (settings true)', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ui: { accessibility: { screenReader: true } },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getScreenReader()).toBe(true);
     });
     it('should use screenReader value from settings if CLI flag is not present (settings false)', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ui: { accessibility: { screenReader: false } },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getScreenReader()).toBe(false);
     });
     it('should prioritize --screen-reader CLI flag (true) over settings (false)', async () => {
         process.argv = ['node', 'script.js', '--screen-reader'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ui: { accessibility: { screenReader: false } },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getScreenReader()).toBe(true);
     });
     it('should be false by default when no flag or setting is present', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {};
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings();
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getScreenReader()).toBe(false);
     });
@@ -1312,8 +1354,8 @@ describe('loadCliConfig tool exclusions', () => {
     it('should not exclude interactive tools in interactive mode without YOLO', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain('run_shell_command');
         expect(config.getExcludeTools()).not.toContain('replace');
         expect(config.getExcludeTools()).not.toContain('write_file');
@@ -1321,8 +1363,8 @@ describe('loadCliConfig tool exclusions', () => {
     it('should not exclude interactive tools in interactive mode with YOLO', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '--yolo'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain('run_shell_command');
         expect(config.getExcludeTools()).not.toContain('replace');
         expect(config.getExcludeTools()).not.toContain('write_file');
@@ -1330,8 +1372,8 @@ describe('loadCliConfig tool exclusions', () => {
     it('should exclude interactive tools in non-interactive mode without YOLO', async () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '-p', 'test'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).toContain('run_shell_command');
         expect(config.getExcludeTools()).toContain('replace');
         expect(config.getExcludeTools()).toContain('write_file');
@@ -1339,8 +1381,8 @@ describe('loadCliConfig tool exclusions', () => {
     it('should not exclude interactive tools in non-interactive mode with YOLO', async () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '-p', 'test', '--yolo'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain('run_shell_command');
         expect(config.getExcludeTools()).not.toContain('replace');
         expect(config.getExcludeTools()).not.toContain('write_file');
@@ -1355,15 +1397,15 @@ describe('loadCliConfig tool exclusions', () => {
             '--allowed-tools',
             'ShellTool',
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain(SHELL_TOOL_NAME);
     });
     it('should exclude web-fetch in non-interactive mode when not allowed', async () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '-p', 'test'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).toContain(WEB_FETCH_TOOL_NAME);
     });
     it('should not exclude web-fetch in non-interactive mode when allowed', async () => {
@@ -1376,8 +1418,8 @@ describe('loadCliConfig tool exclusions', () => {
             '--allowed-tools',
             WEB_FETCH_TOOL_NAME,
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain(WEB_FETCH_TOOL_NAME);
     });
     it('should not exclude shell tool in non-interactive mode when --allowed-tools="run_shell_command" is set', async () => {
@@ -1390,8 +1432,8 @@ describe('loadCliConfig tool exclusions', () => {
             '--allowed-tools',
             'run_shell_command',
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain(SHELL_TOOL_NAME);
     });
     it('should not exclude shell tool in non-interactive mode when --allowed-tools="ShellTool(wc)" is set', async () => {
@@ -1404,8 +1446,8 @@ describe('loadCliConfig tool exclusions', () => {
             '--allowed-tools',
             'ShellTool(wc)',
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain(SHELL_TOOL_NAME);
     });
 });
@@ -1426,36 +1468,36 @@ describe('loadCliConfig interactive', () => {
     it('should be interactive if isTTY and no prompt', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
     });
     it('should be interactive if prompt-interactive is set', async () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '--prompt-interactive', 'test'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
     });
     it('should not be interactive if not isTTY and no prompt', async () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
     });
     it('should not be interactive if prompt is set', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '--prompt', 'test'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
     });
     it('should not be interactive if positional prompt words are provided with other flags', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '--model', 'gemini-2.5-pro', 'Hello'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
     });
     it('should not be interactive if positional prompt words are provided with multiple flags', async () => {
@@ -1468,8 +1510,8 @@ describe('loadCliConfig interactive', () => {
             '--yolo',
             'Hello world',
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         // Verify the question is preserved for one-shot execution
         expect(argv.prompt).toBe('Hello world');
@@ -1478,8 +1520,8 @@ describe('loadCliConfig interactive', () => {
     it('should not be interactive if positional prompt words are provided with extensions flag', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '-e', 'none', 'hello'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('hello');
         expect(argv.extensions).toEqual(['none']);
@@ -1487,8 +1529,8 @@ describe('loadCliConfig interactive', () => {
     it('should handle multiple positional words correctly', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', 'hello world how are you'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('hello world how are you');
         expect(argv.prompt).toBe('hello world how are you');
@@ -1507,8 +1549,8 @@ describe('loadCliConfig interactive', () => {
             'sort',
             'array',
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('write a function to sort array');
         expect(argv.model).toBe('gemini-2.5-pro');
@@ -1516,8 +1558,8 @@ describe('loadCliConfig interactive', () => {
     it('should handle empty positional arguments', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', ''];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
         expect(argv.query).toBeUndefined();
     });
@@ -1534,8 +1576,8 @@ describe('loadCliConfig interactive', () => {
             'are',
             'you',
         ];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('hello world how are you');
         expect(argv.extensions).toEqual(['none']);
@@ -1543,8 +1585,8 @@ describe('loadCliConfig interactive', () => {
     it('should be interactive if no positional prompt words are provided with flags', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '--model', 'gemini-2.5-pro'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
     });
 });
@@ -1568,56 +1610,83 @@ describe('loadCliConfig approval mode', () => {
     });
     it('should default to DEFAULT approval mode when no flags are set', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
     });
     it('should set YOLO approval mode when --yolo flag is used', async () => {
         process.argv = ['node', 'script.js', '--yolo'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
     });
     it('should set YOLO approval mode when -y flag is used', async () => {
         process.argv = ['node', 'script.js', '-y'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
     });
     it('should set DEFAULT approval mode when --approval-mode=default', async () => {
         process.argv = ['node', 'script.js', '--approval-mode', 'default'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
     });
     it('should set AUTO_EDIT approval mode when --approval-mode=auto_edit', async () => {
         process.argv = ['node', 'script.js', '--approval-mode', 'auto_edit'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.AUTO_EDIT);
     });
     it('should set YOLO approval mode when --approval-mode=yolo', async () => {
         process.argv = ['node', 'script.js', '--approval-mode', 'yolo'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
     });
     it('should prioritize --approval-mode over --yolo when both would be valid (but validation prevents this)', async () => {
         // Note: This test documents the intended behavior, but in practice the validation
         // prevents both flags from being used together
         process.argv = ['node', 'script.js', '--approval-mode', 'default'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         // Manually set yolo to true to simulate what would happen if validation didn't prevent it
         argv.yolo = true;
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
     });
     it('should fall back to --yolo behavior when --approval-mode is not set', async () => {
         process.argv = ['node', 'script.js', '--yolo'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
     });
+    it('should set Plan approval mode when --approval-mode=plan is used and experimental.plan is enabled', async () => {
+        process.argv = ['node', 'script.js', '--approval-mode', 'plan'];
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            experimental: {
+                plan: true,
+            },
+        });
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
+    });
+    it('should throw error when --approval-mode=plan is used but experimental.plan is disabled', async () => {
+        process.argv = ['node', 'script.js', '--approval-mode', 'plan'];
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            experimental: {
+                plan: false,
+            },
+        });
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Approval mode "plan" is only available when experimental.plan is enabled.');
+    });
+    it('should throw error when --approval-mode=plan is used but experimental.plan setting is missing', async () => {
+        process.argv = ['node', 'script.js', '--approval-mode', 'plan'];
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({});
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Approval mode "plan" is only available when experimental.plan is enabled.');
+    });
     // --- Untrusted Folder Scenarios ---
     describe('when folder is NOT trusted', () => {
         beforeEach(() => {
@@ -1628,26 +1697,26 @@ describe('loadCliConfig approval mode', () => {
         });
         it('should override --approval-mode=yolo to DEFAULT', async () => {
             process.argv = ['node', 'script.js', '--approval-mode', 'yolo'];
-            const argv = await parseArguments({});
-            const config = await loadCliConfig({}, 'test-session', argv);
+            const argv = await parseArguments(createTestMergedSettings());
+            const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
             expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
         });
         it('should override --approval-mode=auto_edit to DEFAULT', async () => {
             process.argv = ['node', 'script.js', '--approval-mode', 'auto_edit'];
-            const argv = await parseArguments({});
-            const config = await loadCliConfig({}, 'test-session', argv);
+            const argv = await parseArguments(createTestMergedSettings());
+            const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
             expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
         });
         it('should override --yolo flag to DEFAULT', async () => {
             process.argv = ['node', 'script.js', '--yolo'];
-            const argv = await parseArguments({});
-            const config = await loadCliConfig({}, 'test-session', argv);
+            const argv = await parseArguments(createTestMergedSettings());
+            const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
             expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
         });
         it('should remain DEFAULT when --approval-mode=default', async () => {
             process.argv = ['node', 'script.js', '--approval-mode', 'default'];
-            const argv = await parseArguments({});
-            const config = await loadCliConfig({}, 'test-session', argv);
+            const argv = await parseArguments(createTestMergedSettings());
+            const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
             expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
         });
     });
@@ -1668,13 +1737,13 @@ describe('loadCliConfig fileFiltering', () => {
     });
     const testCases = [
         {
-            property: 'disableFuzzySearch',
-            getter: (c) => c.getFileFilteringDisableFuzzySearch(),
+            property: 'enableFuzzySearch',
+            getter: (c) => c.getFileFilteringEnableFuzzySearch(),
             value: true,
         },
         {
-            property: 'disableFuzzySearch',
-            getter: (c) => c.getFileFilteringDisableFuzzySearch(),
+            property: 'enableFuzzySearch',
+            getter: (c) => c.getFileFilteringEnableFuzzySearch(),
             value: false,
         },
         {
@@ -1709,11 +1778,11 @@ describe('loadCliConfig fileFiltering', () => {
         },
     ];
     it.each(testCases)('should pass $property from settings to config when $value', async ({ property, getter, value }) => {
-        const settings = {
+        const settings = createTestMergedSettings({
             context: {
                 fileFiltering: { [property]: value },
             },
-        };
+        });
         const argv = await parseArguments(settings);
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(getter(config)).toBe(value);
@@ -1728,26 +1797,26 @@ describe('Output format', () => {
     });
     it('should default to TEXT', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getOutputFormat()).toBe(OutputFormat.TEXT);
     });
     it('should use the format from settings', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({ output: { format: OutputFormat.JSON } }, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({ output: { format: OutputFormat.JSON } }), 'test-session', argv);
         expect(config.getOutputFormat()).toBe(OutputFormat.JSON);
     });
     it('should prioritize the format from argv', async () => {
         process.argv = ['node', 'script.js', '--output-format', 'json'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({ output: { format: OutputFormat.JSON } }, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({ output: { format: OutputFormat.JSON } }), 'test-session', argv);
         expect(config.getOutputFormat()).toBe(OutputFormat.JSON);
     });
     it('should accept stream-json as a valid output format', async () => {
         process.argv = ['node', 'script.js', '--output-format', 'stream-json'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getOutputFormat()).toBe(OutputFormat.STREAM_JSON);
     });
     it('should error on invalid --output-format argument', async () => {
@@ -1761,7 +1830,7 @@ describe('Output format', () => {
         const debugErrorSpy = vi
             .spyOn(debugLogger, 'error')
             .mockImplementation(() => { });
-        await expect(parseArguments({})).rejects.toThrow('process.exit called');
+        await expect(parseArguments(createTestMergedSettings())).rejects.toThrow('process.exit called');
         expect(debugErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid values:'));
         expect(mockConsoleError).toHaveBeenCalled();
         mockExit.mockRestore();
@@ -1792,7 +1861,7 @@ describe('parseArguments with positional prompt', () => {
         const debugErrorSpy = vi
             .spyOn(debugLogger, 'error')
             .mockImplementation(() => { });
-        await expect(parseArguments({})).rejects.toThrow('process.exit called');
+        await expect(parseArguments(createTestMergedSettings())).rejects.toThrow('process.exit called');
         expect(debugErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Cannot use both a positional prompt and the --prompt (-p) flag together'));
         mockExit.mockRestore();
         mockConsoleError.mockRestore();
@@ -1800,7 +1869,7 @@ describe('parseArguments with positional prompt', () => {
     });
     it('should correctly parse a positional prompt to query field', async () => {
         process.argv = ['node', 'script.js', 'positional', 'prompt'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.query).toBe('positional prompt');
         // Since no explicit prompt flags are set and query doesn't start with @, should map to prompt (one-shot)
         expect(argv.prompt).toBe('positional prompt');
@@ -1812,12 +1881,12 @@ describe('parseArguments with positional prompt', () => {
         // This test verifies that the positional 'query' argument is properly configured
         // with the description: "Positional prompt. Defaults to one-shot; use -i/--prompt-interactive for interactive."
         process.argv = ['node', 'script.js', 'test', 'query'];
-        const argv = await yargsInstance.parseArguments({});
+        const argv = await yargsInstance.parseArguments(createTestMergedSettings());
         expect(argv.query).toBe('test query');
     });
     it('should correctly parse a prompt from the --prompt flag', async () => {
         process.argv = ['node', 'script.js', '--prompt', 'test prompt'];
-        const argv = await parseArguments({});
+        const argv = await parseArguments(createTestMergedSettings());
         expect(argv.prompt).toBe('test prompt');
     });
 });
@@ -1831,28 +1900,30 @@ describe('Telemetry configuration via environment variables', () => {
     it('should prioritize GEMINI_TELEMETRY_ENABLED over settings', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_ENABLED', 'true');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { telemetry: { enabled: false } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            telemetry: { enabled: false },
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(true);
     });
     it('should prioritize GEMINI_TELEMETRY_TARGET over settings', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_TARGET', 'gcp');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             telemetry: { target: ServerConfig.TelemetryTarget.LOCAL },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryTarget()).toBe('gcp');
     });
     it('should throw when GEMINI_TELEMETRY_TARGET is invalid', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_TARGET', 'bogus');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             telemetry: { target: ServerConfig.TelemetryTarget.GCP },
-        };
+        });
         await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow(/Invalid telemetry configuration: .*Invalid telemetry target/i);
         vi.unstubAllEnvs();
     });
@@ -1860,91 +1931,97 @@ describe('Telemetry configuration via environment variables', () => {
         vi.stubEnv('OTEL_EXPORTER_OTLP_ENDPOINT', 'http://default.env.com');
         vi.stubEnv('GEMINI_TELEMETRY_OTLP_ENDPOINT', 'http://gemini.env.com');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             telemetry: { otlpEndpoint: 'http://settings.com' },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryOtlpEndpoint()).toBe('http://gemini.env.com');
     });
     it('should prioritize GEMINI_TELEMETRY_OTLP_PROTOCOL over settings', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_OTLP_PROTOCOL', 'http');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { telemetry: { otlpProtocol: 'grpc' } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            telemetry: { otlpProtocol: 'grpc' },
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryOtlpProtocol()).toBe('http');
     });
     it('should prioritize GEMINI_TELEMETRY_LOG_PROMPTS over settings', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_LOG_PROMPTS', 'false');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { telemetry: { logPrompts: true } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            telemetry: { logPrompts: true },
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
     });
     it('should prioritize GEMINI_TELEMETRY_OUTFILE over settings', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_OUTFILE', '/gemini/env/telemetry.log');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             telemetry: { outfile: '/settings/telemetry.log' },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryOutfile()).toBe('/gemini/env/telemetry.log');
     });
     it('should prioritize GEMINI_TELEMETRY_USE_COLLECTOR over settings', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_USE_COLLECTOR', 'true');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { telemetry: { useCollector: false } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
+            telemetry: { useCollector: false },
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryUseCollector()).toBe(true);
     });
     it('should use settings value when GEMINI_TELEMETRY_ENABLED is not set', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_ENABLED', undefined);
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { telemetry: { enabled: true } };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({ telemetry: { enabled: true } });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(true);
     });
     it('should use settings value when GEMINI_TELEMETRY_TARGET is not set', async () => {
         vi.stubEnv('GEMINI_TELEMETRY_TARGET', undefined);
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             telemetry: { target: ServerConfig.TelemetryTarget.LOCAL },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryTarget()).toBe('local');
     });
     it("should treat GEMINI_TELEMETRY_ENABLED='1' as true", async () => {
         vi.stubEnv('GEMINI_TELEMETRY_ENABLED', '1');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(true);
     });
     it("should treat GEMINI_TELEMETRY_ENABLED='0' as false", async () => {
         vi.stubEnv('GEMINI_TELEMETRY_ENABLED', '0');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({ telemetry: { enabled: true } }, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({ telemetry: { enabled: true } }), 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(false);
     });
     it("should treat GEMINI_TELEMETRY_LOG_PROMPTS='1' as true", async () => {
         vi.stubEnv('GEMINI_TELEMETRY_LOG_PROMPTS', '1');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
     });
     it("should treat GEMINI_TELEMETRY_LOG_PROMPTS='false' as false", async () => {
         vi.stubEnv('GEMINI_TELEMETRY_LOG_PROMPTS', 'false');
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({ telemetry: { logPrompts: true } }, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings({ telemetry: { logPrompts: true } }), 'test-session', argv);
         expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
     });
 });
@@ -1962,8 +2039,8 @@ describe('PolicyEngine nonInteractive wiring', () => {
     it('should set nonInteractive to true in one-shot mode', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', 'echo hello']; // Positional query makes it one-shot
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(config.getPolicyEngine()
             .nonInteractive).toBe(true);
@@ -1971,8 +2048,8 @@ describe('PolicyEngine nonInteractive wiring', () => {
     it('should set nonInteractive to false in interactive mode', async () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const config = await loadCliConfig({}, 'test-session', argv);
+        const argv = await parseArguments(createTestMergedSettings());
+        const config = await loadCliConfig(createTestMergedSettings(), 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
         expect(config.getPolicyEngine()
             .nonInteractive).toBe(false);
@@ -1991,8 +2068,10 @@ describe('Policy Engine Integration in loadCliConfig', () => {
     });
     it('should pass merged allowed tools from CLI and settings to createPolicyEngineConfig', async () => {
         process.argv = ['node', 'script.js', '--allowed-tools', 'cli-tool'];
-        const settings = { tools: { allowed: ['settings-tool'] } };
-        const argv = await parseArguments({});
+        const settings = createTestMergedSettings({
+            tools: { allowed: ['settings-tool'] },
+        });
+        const argv = await parseArguments(createTestMergedSettings());
         await loadCliConfig(settings, 'test-session', argv);
         expect(ServerConfig.createPolicyEngineConfig).toHaveBeenCalledWith(expect.objectContaining({
             tools: expect.objectContaining({
@@ -2003,8 +2082,10 @@ describe('Policy Engine Integration in loadCliConfig', () => {
     it('should pass merged exclude tools from CLI logic and settings to createPolicyEngineConfig', async () => {
         process.stdin.isTTY = false; // Non-interactive to trigger default excludes
         process.argv = ['node', 'script.js', '-p', 'test'];
-        const settings = { tools: { exclude: ['settings-exclude'] } };
-        const argv = await parseArguments({});
+        const settings = createTestMergedSettings({
+            tools: { exclude: ['settings-exclude'] },
+        });
+        const argv = await parseArguments(createTestMergedSettings());
         await loadCliConfig(settings, 'test-session', argv);
         // In non-interactive mode, ShellTool, etc. are excluded
         expect(ServerConfig.createPolicyEngineConfig).toHaveBeenCalledWith(expect.objectContaining({
@@ -2031,19 +2112,19 @@ describe('loadCliConfig disableYoloMode', () => {
     });
     it('should allow auto_edit mode even if yolo mode is disabled', async () => {
         process.argv = ['node', 'script.js', '--approval-mode=auto_edit'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             security: { disableYoloMode: true },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ApprovalMode.AUTO_EDIT);
     });
     it('should throw if YOLO mode is attempted when disableYoloMode is true', async () => {
         process.argv = ['node', 'script.js', '--yolo'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             security: { disableYoloMode: true },
-        };
+        });
         await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
     });
 });
@@ -2064,32 +2145,32 @@ describe('loadCliConfig secureModeEnabled', () => {
     });
     it('should throw an error if YOLO mode is attempted when secureModeEnabled is true', async () => {
         process.argv = ['node', 'script.js', '--yolo'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             admin: {
                 secureModeEnabled: true,
             },
-        };
+        });
         await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
     });
     it('should throw an error if approval-mode=yolo is attempted when secureModeEnabled is true', async () => {
         process.argv = ['node', 'script.js', '--approval-mode=yolo'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             admin: {
                 secureModeEnabled: true,
             },
-        };
+        });
         await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
     });
     it('should set disableYoloMode to true when secureModeEnabled is true', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             admin: {
                 secureModeEnabled: true,
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.isYoloModeDisabled()).toBe(true);
     });
@@ -2115,8 +2196,8 @@ describe('loadCliConfig mcpEnabled', () => {
     };
     it('should enable MCP by default', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = { ...mcpSettings };
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({ ...mcpSettings });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getMcpEnabled()).toBe(true);
         expect(config.getMcpServerCommand()).toBe('mcp-server');
@@ -2126,15 +2207,15 @@ describe('loadCliConfig mcpEnabled', () => {
     });
     it('should disable MCP when mcpEnabled is false', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...mcpSettings,
             admin: {
                 mcp: {
                     enabled: false,
                 },
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getMcpEnabled()).toBe(false);
         expect(config.getMcpServerCommand()).toBeUndefined();
@@ -2144,15 +2225,15 @@ describe('loadCliConfig mcpEnabled', () => {
     });
     it('should enable MCP when mcpEnabled is true', async () => {
         process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {
+        const argv = await parseArguments(createTestMergedSettings());
+        const settings = createTestMergedSettings({
             ...mcpSettings,
             admin: {
                 mcp: {
                     enabled: true,
                 },
             },
-        };
+        });
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getMcpEnabled()).toBe(true);
         expect(config.getMcpServerCommand()).toBe('mcp-server');