@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc2

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

@@ -6,10 +6,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_MODEL_AUTO, OutputFormat, SHELL_TOOL_NAME, WRITE_FILE_TOOL_NAME, EDIT_TOOL_NAME, } from '@google/gemini-cli-core';
+import { DEFAULT_FILE_FILTERING_OPTIONS, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_MODEL_AUTO, OutputFormat, SHELL_TOOL_NAME, WRITE_FILE_TOOL_NAME, EDIT_TOOL_NAME, } from '@google/gemini-cli-core';
 import { loadCliConfig, parseArguments } from './config.js';
 import * as ServerConfig from '@google/gemini-cli-core';
 import { isWorkspaceTrusted } from './trustedFolders.js';
+import { ExtensionManager } from './extension-manager.js';
 vi.mock('./trustedFolders.js', () => ({
     isWorkspaceTrusted: vi
         .fn()
@@ -72,10 +73,15 @@ vi.mock('@google/gemini-cli-core', async () => {
             }),
         },
         loadEnvironment: vi.fn(),
-        loadServerHierarchicalMemory: vi.fn((cwd, dirs, debug, fileService, extensionPaths, _maxDirs) => Promise.resolve({
-            memoryContent: extensionPaths?.join(',') || '',
-            fileCount: extensionPaths?.length || 0,
-        })),
+        loadServerHierarchicalMemory: vi.fn((cwd, dirs, debug, fileService, extensionLoader, _maxDirs) => {
+            const extensionPaths = extensionLoader
+                .getExtensions()
+                .flatMap((e) => e.contextFiles);
+            return Promise.resolve({
+                memoryContent: extensionPaths.join(',') || '',
+                fileCount: extensionPaths?.length || 0,
+            });
+        }),
         DEFAULT_MEMORY_FILE_FILTERING_OPTIONS: {
             respectGitIgnore: false,
             respectGeminiIgnore: true,
@@ -86,11 +92,23 @@ vi.mock('@google/gemini-cli-core', async () => {
         },
     };
 });
+vi.mock('./extension-manager.js');
+// Global setup to ensure clean environment for all tests in this file
+const originalArgv = process.argv;
+const originalGeminiModel = process.env['GEMINI_MODEL'];
+beforeEach(() => {
+    delete process.env['GEMINI_MODEL'];
+});
+afterEach(() => {
+    process.argv = originalArgv;
+    if (originalGeminiModel !== undefined) {
+        process.env['GEMINI_MODEL'] = originalGeminiModel;
+    }
+    else {
+        delete process.env['GEMINI_MODEL'];
+    }
+});
 describe('parseArguments', () => {
-    const originalArgv = process.argv;
-    afterEach(() => {
-        process.argv = originalArgv;
-    });
     it('should throw an error when both --prompt and --prompt-interactive are used together', async () => {
         process.argv = [
             'node',
@@ -176,13 +194,13 @@ describe('parseArguments', () => {
             '@path',
             './file.md',
             '--model',
-            'gemini-1.5-pro',
+            'gemini-2.5-pro',
         ];
         const argv = await parseArguments({});
         expect(argv.query).toBe('@path ./file.md');
         expect(argv.prompt).toBe('@path ./file.md'); // Should map to one-shot
         expect(argv.promptInteractive).toBeUndefined();
-        expect(argv.model).toBe('gemini-1.5-pro');
+        expect(argv.model).toBe('gemini-2.5-pro');
     });
     it('maps unquoted positional @path + arg to prompt (one-shot)', async () => {
         // Simulate: gemini @path ./file.md
@@ -380,14 +398,13 @@ describe('parseArguments', () => {
     });
 });
 describe('loadCliConfig', () => {
-    const originalArgv = process.argv;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
@@ -419,7 +436,7 @@ describe('loadCliConfig', () => {
             process.argv = ['node', 'script.js'];
             const argv = await parseArguments({});
             const settings = {};
-            const config = await loadCliConfig(settings, [], 'test-session', argv);
+            const config = await loadCliConfig(settings, 'test-session', argv);
             expect(config.getProxy()).toBeFalsy();
         });
         const proxy_url = 'http://localhost:7890';
@@ -459,11 +476,19 @@ describe('loadCliConfig', () => {
                 process.argv = ['node', 'script.js'];
                 const argv = await parseArguments({});
                 const settings = {};
-                const config = await loadCliConfig(settings, [], 'test-session', argv);
+                const config = await loadCliConfig(settings, 'test-session', argv);
                 expect(config.getProxy()).toBe(expected);
             });
         });
     });
+    it('should use default fileFilter options when unconfigured', async () => {
+        process.argv = ['node', 'script.js'];
+        const argv = await parseArguments({});
+        const settings = {};
+        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);
+    });
 });
 describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
     beforeEach(() => {
@@ -477,7 +502,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 extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
                 name: 'ext1',
@@ -505,10 +530,10 @@ describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
                 ],
                 isActive: true,
             },
-        ];
+        ]);
         const argv = await parseArguments({});
-        await loadCliConfig(settings, extensions, 'session-id', argv);
-        expect(ServerConfig.loadServerHierarchicalMemory).toHaveBeenCalledWith(expect.any(String), [], false, expect.any(Object), extensions, true, 'tree', {
+        await loadCliConfig(settings, 'session-id', argv);
+        expect(ServerConfig.loadServerHierarchicalMemory).toHaveBeenCalledWith(expect.any(String), [], false, expect.any(Object), expect.any(ExtensionManager), true, 'tree', {
             respectGitIgnore: false,
             respectGeminiIgnore: true,
         }, undefined);
@@ -532,7 +557,7 @@ describe('mergeMcpServers', () => {
                 },
             },
         };
-        const extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
                 name: 'ext1',
@@ -546,11 +571,11 @@ describe('mergeMcpServers', () => {
                 contextFiles: [],
                 isActive: true,
             },
-        ];
+        ]);
         const originalSettings = JSON.parse(JSON.stringify(settings));
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        await loadCliConfig(settings, extensions, 'test-session', argv);
+        await loadCliConfig(settings, 'test-session', argv);
         expect(settings).toEqual(originalSettings);
     });
 });
@@ -562,6 +587,7 @@ describe('mergeExcludeTools', () => {
     ];
     const originalIsTTY = process.stdin.isTTY;
     beforeEach(() => {
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
         process.stdin.isTTY = true;
     });
     afterEach(() => {
@@ -569,7 +595,7 @@ describe('mergeExcludeTools', () => {
     });
     it('should merge excludeTools from settings and extensions', async () => {
         const settings = { tools: { exclude: ['tool1', 'tool2'] } };
-        const extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
                 name: 'ext1',
@@ -588,16 +614,16 @@ describe('mergeExcludeTools', () => {
                 contextFiles: [],
                 isActive: true,
             },
-        ];
+        ]);
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(expect.arrayContaining(['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 extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
                 name: 'ext1',
@@ -607,16 +633,16 @@ describe('mergeExcludeTools', () => {
                 contextFiles: [],
                 isActive: true,
             },
-        ];
+        ]);
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(expect.arrayContaining(['tool1', 'tool2', 'tool3']));
         expect(config.getExcludeTools()).toHaveLength(3);
     });
     it('should handle overlapping excludeTools between extensions', async () => {
         const settings = { tools: { exclude: ['tool1'] } };
-        const extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext1',
                 name: 'ext1',
@@ -635,43 +661,41 @@ describe('mergeExcludeTools', () => {
                 contextFiles: [],
                 isActive: true,
             },
-        ];
+        ]);
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(expect.arrayContaining(['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 extensions = [];
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual([]);
     });
     it('should return default excludes when no excludeTools are specified and it is not interactive', async () => {
         process.stdin.isTTY = false;
         const settings = {};
-        const extensions = [];
         process.argv = ['node', 'script.js', '-p', 'test'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        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 extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(expect.arrayContaining(['tool1', 'tool2']));
         expect(config.getExcludeTools()).toHaveLength(2);
     });
     it('should handle extensions with excludeTools but no settings', async () => {
         const settings = {};
-        const extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext',
                 name: 'ext1',
@@ -681,16 +705,16 @@ describe('mergeExcludeTools', () => {
                 contextFiles: [],
                 isActive: true,
             },
-        ];
+        ]);
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getExcludeTools()).toEqual(expect.arrayContaining(['tool1', 'tool2']));
         expect(config.getExcludeTools()).toHaveLength(2);
     });
     it('should not modify the original settings object', async () => {
         const settings = { tools: { exclude: ['tool1'] } };
-        const extensions = [
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([
             {
                 path: '/path/to/ext',
                 name: 'ext1',
@@ -700,11 +724,11 @@ describe('mergeExcludeTools', () => {
                 contextFiles: [],
                 isActive: true,
             },
-        ];
+        ]);
         const originalSettings = JSON.parse(JSON.stringify(settings));
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        await loadCliConfig(settings, extensions, 'test-session', argv);
+        await loadCliConfig(settings, 'test-session', argv);
         expect(settings).toEqual(originalSettings);
     });
 });
@@ -716,6 +740,7 @@ describe('Approval mode tool exclusion logic', () => {
             isTrusted: true,
             source: undefined,
         });
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
         process.stdin.isTTY = originalIsTTY;
@@ -724,8 +749,7 @@ describe('Approval mode tool exclusion logic', () => {
         process.argv = ['node', 'script.js', '-p', 'test'];
         const argv = await parseArguments({});
         const settings = {};
-        const extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain(SHELL_TOOL_NAME);
         expect(excludedTools).toContain(EDIT_TOOL_NAME);
@@ -742,8 +766,7 @@ describe('Approval mode tool exclusion logic', () => {
         ];
         const argv = await parseArguments({});
         const settings = {};
-        const extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain(SHELL_TOOL_NAME);
         expect(excludedTools).toContain(EDIT_TOOL_NAME);
@@ -760,8 +783,7 @@ describe('Approval mode tool exclusion logic', () => {
         ];
         const argv = await parseArguments({});
         const settings = {};
-        const extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain(SHELL_TOOL_NAME);
         expect(excludedTools).not.toContain(EDIT_TOOL_NAME);
@@ -778,8 +800,7 @@ describe('Approval mode tool exclusion logic', () => {
         ];
         const argv = await parseArguments({});
         const settings = {};
-        const extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        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);
@@ -789,8 +810,7 @@ describe('Approval mode tool exclusion logic', () => {
         process.argv = ['node', 'script.js', '--yolo', '-p', 'test'];
         const argv = await parseArguments({});
         const settings = {};
-        const extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        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);
@@ -809,8 +829,7 @@ describe('Approval mode tool exclusion logic', () => {
             process.argv = testCase.args;
             const argv = await parseArguments({});
             const settings = {};
-            const extensions = [];
-            const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+            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);
@@ -828,14 +847,23 @@ describe('Approval mode tool exclusion logic', () => {
         ];
         const argv = await parseArguments({});
         const settings = { tools: { exclude: ['custom_tool'] } };
-        const extensions = [];
-        const config = await loadCliConfig(settings, extensions, 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         const excludedTools = config.getExcludeTools();
         expect(excludedTools).toContain('custom_tool'); // From settings
         expect(excludedTools).toContain(SHELL_TOOL_NAME); // From approval mode
         expect(excludedTools).not.toContain(EDIT_TOOL_NAME); // Should be allowed in auto_edit
         expect(excludedTools).not.toContain(WRITE_FILE_TOOL_NAME); // Should be allowed in auto_edit
     });
+    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 = {
+            security: {
+                disableYoloMode: true,
+            },
+        };
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode when it is disabled by settings');
+    });
     it('should throw an error for invalid approval mode values in loadCliConfig', async () => {
         // Create a mock argv with an invalid approval mode that bypasses argument parsing validation
         const invalidArgv = {
@@ -845,19 +873,17 @@ describe('Approval mode tool exclusion logic', () => {
             yolo: false,
         };
         const settings = {};
-        const extensions = [];
-        await expect(loadCliConfig(settings, extensions, 'test-session', invalidArgv)).rejects.toThrow('Invalid approval mode: invalid_mode. Valid values are: yolo, auto_edit, default');
+        await expect(loadCliConfig(settings, 'test-session', invalidArgv)).rejects.toThrow('Invalid approval mode: invalid_mode. Valid values are: yolo, auto_edit, default');
     });
 });
 describe('loadCliConfig with allowed-mcp-server-names', () => {
-    const originalArgv = process.argv;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
@@ -871,7 +897,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
     it('should allow all MCP servers if the flag is not provided', async () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(baseSettings, [], 'test-session', argv);
+        const config = await loadCliConfig(baseSettings, 'test-session', argv);
         expect(config.getMcpServers()).toEqual(baseSettings.mcpServers);
     });
     it('should allow only the specified MCP server', async () => {
@@ -882,10 +908,8 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             'server1',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(baseSettings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server1: { url: 'http://localhost:8080' },
-        });
+        const config = await loadCliConfig(baseSettings, 'test-session', argv);
+        expect(config.getAllowedMcpServers()).toEqual(['server1']);
     });
     it('should allow multiple specified MCP servers', async () => {
         process.argv = [
@@ -897,11 +921,8 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             'server3',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(baseSettings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server1: { url: 'http://localhost:8080' },
-            server3: { url: 'http://localhost:8082' },
-        });
+        const config = await loadCliConfig(baseSettings, 'test-session', argv);
+        expect(config.getAllowedMcpServers()).toEqual(['server1', 'server3']);
     });
     it('should handle server names that do not exist', async () => {
         process.argv = [
@@ -913,16 +934,14 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             'server4',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig(baseSettings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server1: { url: 'http://localhost:8080' },
-        });
+        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 config = await loadCliConfig(baseSettings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({});
+        const config = await loadCliConfig(baseSettings, 'test-session', argv);
+        expect(config.getAllowedMcpServers()).toEqual(['']);
     });
     it('should read allowMCPServers from settings', async () => {
         process.argv = ['node', 'script.js'];
@@ -931,11 +950,8 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             ...baseSettings,
             mcp: { allowed: ['server1', 'server2'] },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server1: { url: 'http://localhost:8080' },
-            server2: { url: 'http://localhost:8081' },
-        });
+        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'];
@@ -944,10 +960,8 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
             ...baseSettings,
             mcp: { excluded: ['server1', 'server2'] },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server3: { url: 'http://localhost:8082' },
-        });
+        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'];
@@ -959,10 +973,9 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
                 allowed: ['server1', 'server2'],
             },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server2: { url: 'http://localhost:8081' },
-        });
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getAllowedMcpServers()).toEqual(['server1', 'server2']);
+        expect(config.getBlockedMcpServers()).toEqual(['server1']);
     });
     it('should prioritize mcp server flag if set', async () => {
         process.argv = [
@@ -979,10 +992,8 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
                 allowed: ['server2'],
             },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server1: { url: 'http://localhost:8080' },
-        });
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getAllowedMcpServers()).toEqual(['server1']);
     });
     it('should prioritize CLI flag over both allowed and excluded settings', async () => {
         process.argv = [
@@ -1001,52 +1012,62 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
                 excluded: ['server3'], // Should be ignored
             },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getMcpServers()).toEqual({
-            server2: { url: 'http://localhost:8081' },
-            server3: { url: 'http://localhost:8082' },
-        });
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getAllowedMcpServers()).toEqual(['server2', 'server3']);
+        expect(config.getBlockedMcpServers()).toEqual([]);
     });
 });
 describe('loadCliConfig model selection', () => {
+    beforeEach(() => {
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
     it('selects a model from settings.json if provided', async () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const config = await loadCliConfig({
             model: {
-                name: 'gemini-9001-ultra',
+                name: 'gemini-2.5-pro',
             },
-        }, [], 'test-session', argv);
-        expect(config.getModel()).toBe('gemini-9001-ultra');
+        }, '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({
         // No model set.
-        }, [], 'test-session', argv);
+        }, 'test-session', argv);
         expect(config.getModel()).toBe(DEFAULT_GEMINI_MODEL);
     });
     it('always prefers model from argv', async () => {
-        process.argv = ['node', 'script.js', '--model', 'gemini-8675309-ultra'];
+        process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash-preview'];
         const argv = await parseArguments({});
         const config = await loadCliConfig({
             model: {
-                name: 'gemini-9001-ultra',
+                name: 'gemini-2.5-pro',
             },
-        }, [], 'test-session', argv);
-        expect(config.getModel()).toBe('gemini-8675309-ultra');
+        }, '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-8675309-ultra'];
+        process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash-preview'];
         const argv = await parseArguments({});
         const config = await loadCliConfig({
         // No model provided via settings.
-        }, [], 'test-session', argv);
-        expect(config.getModel()).toBe('gemini-8675309-ultra');
+        }, 'test-session', argv);
+        expect(config.getModel()).toBe('gemini-2.5-flash-preview');
     });
 });
 describe('loadCliConfig model selection with model router', () => {
+    beforeEach(() => {
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
     it('should use auto model when useModelRouter is true and no model is provided', async () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
@@ -1054,7 +1075,7 @@ describe('loadCliConfig model selection with model router', () => {
             experimental: {
                 useModelRouter: true,
             },
-        }, [], 'test-session', argv);
+        }, 'test-session', argv);
         expect(config.getModel()).toBe(DEFAULT_GEMINI_MODEL_AUTO);
     });
     it('should use default model when useModelRouter is false and no model is provided', async () => {
@@ -1064,7 +1085,7 @@ describe('loadCliConfig model selection with model router', () => {
             experimental: {
                 useModelRouter: false,
             },
-        }, [], 'test-session', argv);
+        }, 'test-session', argv);
         expect(config.getModel()).toBe(DEFAULT_GEMINI_MODEL);
     });
     it('should prioritize argv over useModelRouter', async () => {
@@ -1074,7 +1095,7 @@ describe('loadCliConfig model selection with model router', () => {
             experimental: {
                 useModelRouter: true,
             },
-        }, [], 'test-session', argv);
+        }, 'test-session', argv);
         expect(config.getModel()).toBe('gemini-from-argv');
     });
     it('should prioritize settings over useModelRouter', async () => {
@@ -1087,7 +1108,7 @@ describe('loadCliConfig model selection with model router', () => {
             model: {
                 name: 'gemini-from-settings',
             },
-        }, [], 'test-session', argv);
+        }, 'test-session', argv);
         expect(config.getModel()).toBe('gemini-from-settings');
     });
     it('should prioritize environment variable over useModelRouter', async () => {
@@ -1098,19 +1119,18 @@ describe('loadCliConfig model selection with model router', () => {
             experimental: {
                 useModelRouter: true,
             },
-        }, [], 'test-session', argv);
+        }, 'test-session', argv);
         expect(config.getModel()).toBe('gemini-from-env');
     });
 });
 describe('loadCliConfig folderTrust', () => {
-    const originalArgv = process.argv;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
@@ -1124,7 +1144,7 @@ describe('loadCliConfig folderTrust', () => {
             },
         };
         const argv = await parseArguments({});
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFolderTrust()).toBe(false);
     });
     it('should be true when folderTrust is true', async () => {
@@ -1137,28 +1157,26 @@ describe('loadCliConfig folderTrust', () => {
                 },
             },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        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 config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFolderTrust()).toBe(false);
     });
 });
 describe('loadCliConfig with includeDirectories', () => {
-    const originalArgv = process.argv;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
         vi.spyOn(process, 'cwd').mockReturnValue(path.resolve(path.sep, 'home', 'user', 'project'));
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
-        vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
     it('should combine and resolve paths from settings and CLI arguments', async () => {
@@ -1179,7 +1197,7 @@ describe('loadCliConfig with includeDirectories', () => {
                 ],
             },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         const expected = [
             mockCwd,
             path.resolve(path.sep, 'cli', 'path1'),
@@ -1192,50 +1210,44 @@ describe('loadCliConfig with includeDirectories', () => {
         expect(config.getWorkspaceContext().getDirectories()).toHaveLength(expected.length);
     });
 });
-describe('loadCliConfig chatCompression', () => {
-    const originalArgv = process.argv;
+describe('loadCliConfig compressionThreshold', () => {
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
-    it('should pass chatCompression settings to the core config', async () => {
+    it('should pass settings to the core config', async () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = {
             model: {
-                chatCompression: {
-                    contextPercentageThreshold: 0.5,
-                },
+                compressionThreshold: 0.5,
             },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getChatCompression()).toEqual({
-            contextPercentageThreshold: 0.5,
-        });
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(await config.getCompressionThreshold()).toBe(0.5);
     });
-    it('should have undefined chatCompression if not in settings', async () => {
+    it('should have undefined compressionThreshold if not in settings', async () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = {};
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
-        expect(config.getChatCompression()).toBeUndefined();
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(await config.getCompressionThreshold()).toBeUndefined();
     });
 });
 describe('loadCliConfig useRipgrep', () => {
-    const originalArgv = process.argv;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
@@ -1243,56 +1255,55 @@ describe('loadCliConfig useRipgrep', () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = {};
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        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 config = await loadCliConfig(settings, [], 'test-session', argv);
+        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 config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getUseRipgrep()).toBe(true);
     });
     describe('loadCliConfig useModelRouter', () => {
         it('should be false by default when useModelRouter is not set in settings', async () => {
             process.argv = ['node', 'script.js'];
-            const argv = await parseArguments({});
+            const _argv = await parseArguments({});
             const settings = {};
-            const config = await loadCliConfig(settings, [], 'test-session', argv);
+            const config = await loadCliConfig(settings, 'test-session', _argv);
             expect(config.getUseModelRouter()).toBe(false);
         });
         it('should be true when useModelRouter is set to true in settings', async () => {
             process.argv = ['node', 'script.js'];
             const argv = await parseArguments({});
             const settings = { experimental: { useModelRouter: true } };
-            const config = await loadCliConfig(settings, [], 'test-session', argv);
+            const config = await loadCliConfig(settings, 'test-session', argv);
             expect(config.getUseModelRouter()).toBe(true);
         });
         it('should be false when useModelRouter is explicitly set to false in settings', async () => {
             process.argv = ['node', 'script.js'];
             const argv = await parseArguments({});
             const settings = { experimental: { useModelRouter: false } };
-            const config = await loadCliConfig(settings, [], 'test-session', argv);
+            const config = await loadCliConfig(settings, 'test-session', argv);
             expect(config.getUseModelRouter()).toBe(false);
         });
     });
 });
 describe('screenReader configuration', () => {
-    const originalArgv = process.argv;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
@@ -1302,7 +1313,7 @@ describe('screenReader configuration', () => {
         const settings = {
             ui: { accessibility: { screenReader: true } },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        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 () => {
@@ -1311,7 +1322,7 @@ describe('screenReader configuration', () => {
         const settings = {
             ui: { accessibility: { screenReader: false } },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        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 () => {
@@ -1320,19 +1331,18 @@ describe('screenReader configuration', () => {
         const settings = {
             ui: { accessibility: { screenReader: false } },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        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 config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getScreenReader()).toBe(false);
     });
 });
 describe('loadCliConfig tool exclusions', () => {
-    const originalArgv = process.argv;
     const originalIsTTY = process.stdin.isTTY;
     beforeEach(() => {
         vi.resetAllMocks();
@@ -1343,9 +1353,9 @@ describe('loadCliConfig tool exclusions', () => {
             isTrusted: true,
             source: undefined,
         });
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         process.stdin.isTTY = originalIsTTY;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
@@ -1354,7 +1364,7 @@ describe('loadCliConfig tool exclusions', () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain('run_shell_command');
         expect(config.getExcludeTools()).not.toContain('replace');
         expect(config.getExcludeTools()).not.toContain('write_file');
@@ -1363,7 +1373,7 @@ describe('loadCliConfig tool exclusions', () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '--yolo'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain('run_shell_command');
         expect(config.getExcludeTools()).not.toContain('replace');
         expect(config.getExcludeTools()).not.toContain('write_file');
@@ -1372,7 +1382,7 @@ describe('loadCliConfig tool exclusions', () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '-p', 'test'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getExcludeTools()).toContain('run_shell_command');
         expect(config.getExcludeTools()).toContain('replace');
         expect(config.getExcludeTools()).toContain('write_file');
@@ -1381,7 +1391,7 @@ describe('loadCliConfig tool exclusions', () => {
         process.stdin.isTTY = false;
         process.argv = ['node', 'script.js', '-p', 'test', '--yolo'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain('run_shell_command');
         expect(config.getExcludeTools()).not.toContain('replace');
         expect(config.getExcludeTools()).not.toContain('write_file');
@@ -1397,7 +1407,7 @@ describe('loadCliConfig tool exclusions', () => {
             'ShellTool',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain(SHELL_TOOL_NAME);
     });
     it('should not exclude shell tool in non-interactive mode when --allowed-tools="run_shell_command" is set', async () => {
@@ -1411,7 +1421,7 @@ describe('loadCliConfig tool exclusions', () => {
             'run_shell_command',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, '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 () => {
@@ -1425,21 +1435,20 @@ describe('loadCliConfig tool exclusions', () => {
             'ShellTool(wc)',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getExcludeTools()).not.toContain(SHELL_TOOL_NAME);
     });
 });
 describe('loadCliConfig interactive', () => {
-    const originalArgv = process.argv;
     const originalIsTTY = process.stdin.isTTY;
     beforeEach(() => {
         vi.resetAllMocks();
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
         process.stdin.isTTY = true;
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
-        process.argv = originalArgv;
         process.stdin.isTTY = originalIsTTY;
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
@@ -1448,35 +1457,35 @@ describe('loadCliConfig interactive', () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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-1.5-pro', 'Hello'];
+        process.argv = ['node', 'script.js', '--model', 'gemini-2.5-pro', 'Hello'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
     });
     it('should not be interactive if positional prompt words are provided with multiple flags', async () => {
@@ -1485,12 +1494,12 @@ describe('loadCliConfig interactive', () => {
             'node',
             'script.js',
             '--model',
-            'gemini-1.5-pro',
+            'gemini-2.5-pro',
             '--yolo',
             'Hello world',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         // Verify the question is preserved for one-shot execution
         expect(argv.prompt).toBe('Hello world');
@@ -1500,7 +1509,7 @@ describe('loadCliConfig interactive', () => {
         process.stdin.isTTY = true;
         process.argv = ['node', 'script.js', '-e', 'none', 'hello'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('hello');
         expect(argv.extensions).toEqual(['none']);
@@ -1509,7 +1518,7 @@ describe('loadCliConfig interactive', () => {
         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 config = await loadCliConfig({}, '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');
@@ -1520,7 +1529,7 @@ describe('loadCliConfig interactive', () => {
             'node',
             'script.js',
             '--model',
-            'gemini-1.5-pro',
+            'gemini-2.5-pro',
             'write',
             'a',
             'function',
@@ -1529,16 +1538,16 @@ describe('loadCliConfig interactive', () => {
             'array',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('write a function to sort array');
-        expect(argv.model).toBe('gemini-1.5-pro');
+        expect(argv.model).toBe('gemini-2.5-pro');
     });
     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 config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
         expect(argv.query).toBeUndefined();
     });
@@ -1556,16 +1565,16 @@ describe('loadCliConfig interactive', () => {
             'you',
         ];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(false);
         expect(argv.query).toBe('hello world how are you');
         expect(argv.extensions).toEqual(['none']);
     });
     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-1.5-pro'];
+        process.argv = ['node', 'script.js', '--model', 'gemini-2.5-pro'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.isInteractive()).toBe(true);
     });
 });
@@ -1580,6 +1589,7 @@ describe('loadCliConfig approval mode', () => {
             isTrusted: true,
             source: undefined,
         });
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
         process.argv = originalArgv;
@@ -1589,37 +1599,37 @@ 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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 () => {
@@ -1629,13 +1639,13 @@ describe('loadCliConfig approval mode', () => {
         const argv = await parseArguments({});
         // 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({}, '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 config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
     });
     // --- Untrusted Folder Scenarios ---
@@ -1649,25 +1659,25 @@ 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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, '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 config = await loadCliConfig({}, 'test-session', argv);
             expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
         });
     });
@@ -1679,6 +1689,7 @@ describe('loadCliConfig fileFiltering', () => {
         vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
         vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
         process.argv = ['node', 'script.js']; // Reset argv for each test
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
     });
     afterEach(() => {
         process.argv = originalArgv;
@@ -1734,33 +1745,39 @@ describe('loadCliConfig fileFiltering', () => {
             },
         };
         const argv = await parseArguments(settings);
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(getter(config)).toBe(value);
     });
 });
 describe('Output format', () => {
+    beforeEach(() => {
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
     it('should default to TEXT', async () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, '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 config = await loadCliConfig({ 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 config = await loadCliConfig({ 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 config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getOutputFormat()).toBe(OutputFormat.STREAM_JSON);
     });
     it('should error on invalid --output-format argument', async () => {
@@ -1826,12 +1843,18 @@ describe('parseArguments with positional prompt', () => {
     });
 });
 describe('Telemetry configuration via environment variables', () => {
+    beforeEach(() => {
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
     it('should prioritize CELL_TELEMETRY_ENABLED over settings', async () => {
         vi.stubEnv('CELL_TELEMETRY_ENABLED', 'true');
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = { telemetry: { enabled: false } };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(true);
     });
     it('should prioritize CELL_TELEMETRY_TARGET over settings', async () => {
@@ -1841,7 +1864,7 @@ describe('Telemetry configuration via environment variables', () => {
         const settings = {
             telemetry: { target: ServerConfig.TelemetryTarget.LOCAL },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryTarget()).toBe('gcp');
     });
     it('should throw when CELL_TELEMETRY_TARGET is invalid', async () => {
@@ -1851,7 +1874,7 @@ describe('Telemetry configuration via environment variables', () => {
         const settings = {
             telemetry: { target: ServerConfig.TelemetryTarget.GCP },
         };
-        await expect(loadCliConfig(settings, [], 'test-session', argv)).rejects.toThrow(/Invalid telemetry configuration: .*Invalid telemetry target/i);
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow(/Invalid telemetry configuration: .*Invalid telemetry target/i);
         vi.unstubAllEnvs();
     });
     it('should prioritize CELL_TELEMETRY_OTLP_ENDPOINT over settings and default env var', async () => {
@@ -1862,7 +1885,7 @@ describe('Telemetry configuration via environment variables', () => {
         const settings = {
             telemetry: { otlpEndpoint: 'http://settings.com' },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryOtlpEndpoint()).toBe('http://gemini.env.com');
     });
     it('should prioritize CELL_TELEMETRY_OTLP_PROTOCOL over settings', async () => {
@@ -1870,7 +1893,7 @@ describe('Telemetry configuration via environment variables', () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = { telemetry: { otlpProtocol: 'grpc' } };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryOtlpProtocol()).toBe('http');
     });
     it('should prioritize CELL_TELEMETRY_LOG_PROMPTS over settings', async () => {
@@ -1878,7 +1901,7 @@ describe('Telemetry configuration via environment variables', () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = { telemetry: { logPrompts: true } };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
     });
     it('should prioritize CELL_TELEMETRY_OUTFILE over settings', async () => {
@@ -1888,7 +1911,7 @@ describe('Telemetry configuration via environment variables', () => {
         const settings = {
             telemetry: { outfile: '/settings/telemetry.log' },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryOutfile()).toBe('/gemini/env/telemetry.log');
     });
     it('should prioritize CELL_TELEMETRY_USE_COLLECTOR over settings', async () => {
@@ -1896,7 +1919,7 @@ describe('Telemetry configuration via environment variables', () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = { telemetry: { useCollector: false } };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryUseCollector()).toBe(true);
     });
     it('should use settings value when CELL_TELEMETRY_ENABLED is not set', async () => {
@@ -1904,7 +1927,7 @@ describe('Telemetry configuration via environment variables', () => {
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
         const settings = { telemetry: { enabled: true } };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(true);
     });
     it('should use settings value when CELL_TELEMETRY_TARGET is not set', async () => {
@@ -1914,35 +1937,35 @@ describe('Telemetry configuration via environment variables', () => {
         const settings = {
             telemetry: { target: ServerConfig.TelemetryTarget.LOCAL },
         };
-        const config = await loadCliConfig(settings, [], 'test-session', argv);
+        const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getTelemetryTarget()).toBe('local');
     });
     it("should treat CELL_TELEMETRY_ENABLED='1' as true", async () => {
         vi.stubEnv('CELL_TELEMETRY_ENABLED', '1');
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(true);
     });
     it("should treat CELL_TELEMETRY_ENABLED='0' as false", async () => {
         vi.stubEnv('CELL_TELEMETRY_ENABLED', '0');
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({ telemetry: { enabled: true } }, [], 'test-session', argv);
+        const config = await loadCliConfig({ telemetry: { enabled: true } }, 'test-session', argv);
         expect(config.getTelemetryEnabled()).toBe(false);
     });
     it("should treat CELL_TELEMETRY_LOG_PROMPTS='1' as true", async () => {
         vi.stubEnv('CELL_TELEMETRY_LOG_PROMPTS', '1');
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({}, [], 'test-session', argv);
+        const config = await loadCliConfig({}, 'test-session', argv);
         expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
     });
     it("should treat CELL_TELEMETRY_LOG_PROMPTS='false' as false", async () => {
         vi.stubEnv('CELL_TELEMETRY_LOG_PROMPTS', 'false');
         process.argv = ['node', 'script.js'];
         const argv = await parseArguments({});
-        const config = await loadCliConfig({ telemetry: { logPrompts: true } }, [], 'test-session', argv);
+        const config = await loadCliConfig({ telemetry: { logPrompts: true } }, 'test-session', argv);
         expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
     });
 });