@office-ai/aioncli-core 0.26.0 → 0.30.1

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

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
@@ -9,10 +9,12 @@ import { ExperimentFlags } from '../code_assist/experiments/flagNames.js';
 import { debugLogger } from '../utils/debugLogger.js';
 import { ApprovalMode } from '../policy/types.js';
 import { HookType, HookEventName } from '../hooks/types.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
 import * as path from 'node:path';
+import * as fs from 'node:fs';
 import { setGeminiMdFilename as mockSetGeminiMdFilename } from '../tools/memoryTool.js';
 import { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, } from '../telemetry/index.js';
-import { AuthType, createContentGeneratorConfig, } from '../core/contentGenerator.js';
+import { AuthType, createContentGenerator, createContentGeneratorConfig, } from '../core/contentGenerator.js';
 import { GeminiClient } from '../core/client.js';
 import { GitService } from '../services/gitService.js';
 import { ShellTool } from '../tools/shell.js';
@@ -24,7 +26,8 @@ import { RipgrepFallbackEvent } from '../telemetry/types.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
 import { ACTIVATE_SKILL_TOOL_NAME } from '../tools/tool-names.js';
 import { DEFAULT_MODEL_CONFIGS } from './defaultModelConfigs.js';
-import { DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_MODEL_AUTO, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_MODEL_AUTO, } from './models.js';
+import { DEFAULT_GEMINI_MODEL } from './models.js';
+import { Storage } from './storage.js';
 vi.mock('fs', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -85,6 +88,8 @@ vi.mock('../core/client.js', () => ({
         initialize: vi.fn().mockResolvedValue(undefined),
         stripThoughtsFromHistory: vi.fn(),
         isInitialized: vi.fn().mockReturnValue(false),
+        setTools: vi.fn().mockResolvedValue(undefined),
+        updateSystemInstruction: vi.fn(),
     })),
 }));
 vi.mock('../telemetry/index.js', async (importOriginal) => {
@@ -109,6 +114,7 @@ vi.mock('../services/gitService.js', () => {
     GitServiceMock.prototype.initialize = vi.fn();
     return { GitService: GitServiceMock };
 });
+vi.mock('../services/fileDiscoveryService.js');
 vi.mock('../ide/ide-client.js', () => ({
     IdeClient: {
         getInstance: vi.fn().mockResolvedValue({
@@ -125,8 +131,8 @@ vi.mock('../agents/registry.js', () => {
     AgentRegistryMock.prototype.getDefinition = vi.fn();
     return { AgentRegistry: AgentRegistryMock };
 });
-vi.mock('../agents/delegate-to-agent-tool.js', () => ({
-    DelegateToAgentTool: vi.fn(),
+vi.mock('../agents/subagent-tool.js', () => ({
+    SubagentTool: vi.fn(),
 }));
 vi.mock('../resources/resource-registry.js', () => ({
     ResourceRegistry: vi.fn(),
@@ -135,21 +141,38 @@ const mockCoreEvents = vi.hoisted(() => ({
     emitFeedback: vi.fn(),
     emitModelChanged: vi.fn(),
     emitConsoleLog: vi.fn(),
+    emitQuotaChanged: vi.fn(),
+    on: vi.fn(),
 }));
 const mockSetGlobalProxy = vi.hoisted(() => vi.fn());
-vi.mock('../utils/events.js', () => ({
-    coreEvents: mockCoreEvents,
-}));
+vi.mock('../utils/events.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        coreEvents: mockCoreEvents,
+    };
+});
 vi.mock('../utils/fetch.js', () => ({
     setGlobalProxy: mockSetGlobalProxy,
 }));
-vi.mock('../services/contextManager.js');
+vi.mock('../services/contextManager.js', () => ({
+    ContextManager: vi.fn().mockImplementation(() => ({
+        refresh: vi.fn(),
+        getGlobalMemory: vi.fn().mockReturnValue(''),
+        getExtensionMemory: vi.fn().mockReturnValue(''),
+        getEnvironmentMemory: vi.fn().mockReturnValue(''),
+        getLoadedPaths: vi.fn().mockReturnValue(new Set()),
+    })),
+}));
 import { BaseLlmClient } from '../core/baseLlmClient.js';
 import { tokenLimit } from '../core/tokenLimits.js';
 import { uiTelemetryService } from '../telemetry/index.js';
 import { getCodeAssistServer } from '../code_assist/codeAssist.js';
 import { getExperiments } from '../code_assist/experiments/experiments.js';
 import { ContextManager } from '../services/contextManager.js';
+import { UserTierId } from '../code_assist/types.js';
+import { ExitPlanModeTool } from '../tools/exit-plan-mode.js';
+import { EnterPlanModeTool } from '../tools/enter-plan-mode.js';
 vi.mock('../core/baseLlmClient.js');
 vi.mock('../core/tokenLimits.js', () => ({
     tokenLimit: vi.fn(),
@@ -185,11 +208,15 @@ describe('Server Config (config.ts)', () => {
     beforeEach(() => {
         // Reset mocks if necessary
         vi.clearAllMocks();
+        vi.mocked(getExperiments).mockResolvedValue({
+            experimentIds: [],
+            flags: {},
+        });
     });
     describe('initialize', () => {
         it('should throw an error if checkpointing is enabled and GitService fails', async () => {
             const gitError = new Error('Git is not installed');
-            GitService.prototype.initialize.mockRejectedValue(gitError);
+            vi.mocked(GitService.prototype.initialize).mockRejectedValue(gitError);
             const config = new Config({
                 ...baseParams,
                 checkpointing: true,
@@ -198,20 +225,71 @@ describe('Server Config (config.ts)', () => {
         });
         it('should not throw an error if checkpointing is disabled and GitService fails', async () => {
             const gitError = new Error('Git is not installed');
-            GitService.prototype.initialize.mockRejectedValue(gitError);
+            vi.mocked(GitService.prototype.initialize).mockRejectedValue(gitError);
             const config = new Config({
                 ...baseParams,
                 checkpointing: false,
             });
             await expect(config.initialize()).resolves.toBeUndefined();
         });
-        it('should throw an error if initialized more than once', async () => {
+        it('should deduplicate multiple calls to initialize', async () => {
             const config = new Config({
                 ...baseParams,
                 checkpointing: false,
             });
-            await expect(config.initialize()).resolves.toBeUndefined();
-            await expect(config.initialize()).rejects.toThrow('Config was already initialized');
+            const storageSpy = vi.spyOn(Storage.prototype, 'initialize');
+            await Promise.all([
+                config.initialize(),
+                config.initialize(),
+                config.initialize(),
+            ]);
+            expect(storageSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should await MCP initialization in non-interactive mode', async () => {
+            const config = new Config({
+                ...baseParams,
+                checkpointing: false,
+                // interactive defaults to false
+            });
+            const { McpClientManager } = await import('../tools/mcp-client-manager.js');
+            let mcpStarted = false;
+            vi.mocked(McpClientManager).mockImplementation(() => ({
+                startConfiguredMcpServers: vi.fn().mockImplementation(async () => {
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                    mcpStarted = true;
+                }),
+                getMcpInstructions: vi.fn(),
+            }));
+            await config.initialize();
+            // Should wait for MCP to finish
+            expect(mcpStarted).toBe(true);
+        });
+        it('should not await MCP initialization in interactive mode', async () => {
+            const config = new Config({
+                ...baseParams,
+                checkpointing: false,
+                interactive: true,
+            });
+            const { McpClientManager } = await import('../tools/mcp-client-manager.js');
+            let mcpStarted = false;
+            let resolveMcp;
+            const mcpPromise = new Promise((resolve) => {
+                resolveMcp = resolve;
+            });
+            McpClientManager.mockImplementation(() => ({
+                startConfiguredMcpServers: vi.fn().mockImplementation(async () => {
+                    await mcpPromise;
+                    mcpStarted = true;
+                }),
+                getMcpInstructions: vi.fn(),
+            }));
+            await config.initialize();
+            // Should return immediately, before MCP finishes
+            expect(mcpStarted).toBe(false);
+            // Now let it finish
+            resolveMcp(undefined);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(mcpStarted).toBe(true);
         });
         describe('getCompressionThreshold', () => {
             it('should return the local compression threshold if it is set', async () => {
@@ -305,98 +383,40 @@ describe('Server Config (config.ts)', () => {
             const config = new Config(baseParams);
             const service = config.getModelAvailabilityService();
             const spy = vi.spyOn(service, 'reset');
-            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({
+                authType,
+            }));
             await config.refreshAuth(AuthType.USE_GEMINI);
             expect(spy).toHaveBeenCalled();
         });
         it('should strip thoughts when switching from GenAI to Vertex', async () => {
             const config = new Config(baseParams);
-            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({
+                authType,
+            }));
             await config.refreshAuth(AuthType.USE_GEMINI);
             await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
             expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
         });
         it('should strip thoughts when switching from GenAI to Vertex AI', async () => {
             const config = new Config(baseParams);
-            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({
+                authType,
+            }));
             await config.refreshAuth(AuthType.USE_GEMINI);
             await config.refreshAuth(AuthType.USE_VERTEX_AI);
             expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
         });
         it('should not strip thoughts when switching from Vertex to GenAI', async () => {
             const config = new Config(baseParams);
-            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({
+                authType,
+            }));
             await config.refreshAuth(AuthType.USE_VERTEX_AI);
             await config.refreshAuth(AuthType.USE_GEMINI);
             expect(config.getGeminiClient().stripThoughtsFromHistory).not.toHaveBeenCalledWith();
         });
     });
-    describe('Preview Features Logic in refreshAuth', () => {
-        beforeEach(() => {
-            // Set up default mock behavior for these functions before each test
-            vi.mocked(getCodeAssistServer).mockReturnValue(undefined);
-            vi.mocked(getExperiments).mockResolvedValue({
-                flags: {},
-                experimentIds: [],
-            });
-        });
-        it('should enable preview features for Google auth when remote flag is true', async () => {
-            // Override the default mock for this specific test
-            vi.mocked(getCodeAssistServer).mockReturnValue({}); // Simulate Google auth by returning a truthy value
-            vi.mocked(getExperiments).mockResolvedValue({
-                flags: {
-                    [ExperimentFlags.ENABLE_PREVIEW]: { boolValue: true },
-                },
-                experimentIds: [],
-            });
-            const config = new Config({ ...baseParams, previewFeatures: undefined });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getPreviewFeatures()).toBe(true);
-        });
-        it('should disable preview features for Google auth when remote flag is false', async () => {
-            // Override the default mock
-            vi.mocked(getCodeAssistServer).mockReturnValue({});
-            vi.mocked(getExperiments).mockResolvedValue({
-                flags: {
-                    [ExperimentFlags.ENABLE_PREVIEW]: { boolValue: false },
-                },
-                experimentIds: [],
-            });
-            const config = new Config({ ...baseParams, previewFeatures: undefined });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getPreviewFeatures()).toBe(undefined);
-        });
-        it('should disable preview features for Google auth when remote flag is missing', async () => {
-            // Override the default mock for getCodeAssistServer, the getExperiments mock is already correct
-            vi.mocked(getCodeAssistServer).mockReturnValue({});
-            const config = new Config({ ...baseParams, previewFeatures: undefined });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getPreviewFeatures()).toBe(undefined);
-        });
-        it('should not change preview features or model if it is already set to true', async () => {
-            const initialModel = 'some-other-model';
-            const config = new Config({
-                ...baseParams,
-                previewFeatures: true,
-                model: initialModel,
-            });
-            // It doesn't matter which auth method we use here, the logic should exit early
-            await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(config.getPreviewFeatures()).toBe(true);
-            expect(config.getModel()).toBe(initialModel);
-        });
-        it('should not change preview features or model if it is already set to false', async () => {
-            const initialModel = 'some-other-model';
-            const config = new Config({
-                ...baseParams,
-                previewFeatures: false,
-                model: initialModel,
-            });
-            await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(config.getPreviewFeatures()).toBe(false);
-            expect(config.getModel()).toBe(initialModel);
-        });
-    });
     it('Config constructor should store userMemory correctly', () => {
         const config = new Config(baseParams);
         expect(config.getUserMemory()).toBe(USER_MEMORY);
@@ -436,6 +456,28 @@ describe('Server Config (config.ts)', () => {
         const config = new Config(paramsWithFileFiltering);
         expect(config.getFileFilteringRespectGitIgnore()).toBe(false);
     });
+    it('should set customIgnoreFilePaths from params', () => {
+        const params = {
+            ...baseParams,
+            fileFiltering: {
+                customIgnoreFilePaths: ['/path/to/ignore/file'],
+            },
+        };
+        const config = new Config(params);
+        expect(config.getCustomIgnoreFilePaths()).toStrictEqual([
+            '/path/to/ignore/file',
+        ]);
+    });
+    it('should set customIgnoreFilePaths to empty array if not provided', () => {
+        const params = {
+            ...baseParams,
+            fileFiltering: {
+                respectGitIgnore: true,
+            },
+        };
+        const config = new Config(params);
+        expect(config.getCustomIgnoreFilePaths()).toStrictEqual([]);
+    });
     it('should initialize WorkspaceContext with includeDirectories', () => {
         const includeDirectories = ['dir1', 'dir2'];
         const paramsWithIncludeDirs = {
@@ -502,6 +544,23 @@ describe('Server Config (config.ts)', () => {
         const fileService = config.getFileService();
         expect(fileService).toBeDefined();
     });
+    it('should pass file filtering options to FileDiscoveryService', () => {
+        const configParams = {
+            ...baseParams,
+            fileFiltering: {
+                respectGitIgnore: false,
+                respectGeminiIgnore: false,
+                customIgnoreFilePaths: ['.myignore'],
+            },
+        };
+        const config = new Config(configParams);
+        config.getFileService();
+        expect(FileDiscoveryService).toHaveBeenCalledWith(path.resolve(TARGET_DIR), {
+            respectGitIgnore: false,
+            respectGeminiIgnore: false,
+            customIgnoreFilePaths: ['.myignore'],
+        });
+    });
     describe('Usage Statistics', () => {
         it('defaults usage statistics to enabled if not specified', () => {
             const config = new Config({
@@ -661,6 +720,20 @@ describe('Server Config (config.ts)', () => {
             expect(config.getUseWriteTodos()).toBe(true);
         });
     });
+    describe('Event Driven Scheduler Configuration', () => {
+        it('should default enableEventDrivenScheduler to true when not provided', () => {
+            const config = new Config(baseParams);
+            expect(config.isEventDrivenSchedulerEnabled()).toBe(true);
+        });
+        it('should set enableEventDrivenScheduler to false when provided as false', () => {
+            const params = {
+                ...baseParams,
+                enableEventDrivenScheduler: false,
+            };
+            const config = new Config(params);
+            expect(config.isEventDrivenSchedulerEnabled()).toBe(false);
+        });
+    });
     describe('Shell Tool Inactivity Timeout', () => {
         it('should default to 300000ms (300 seconds) when not provided', () => {
             const config = new Config(baseParams);
@@ -714,10 +787,14 @@ describe('Server Config (config.ts)', () => {
             const wasReadFileToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ReadFileTool));
             expect(wasReadFileToolRegistered).toBe(false);
         });
-        it('should register subagents as tools when codebaseInvestigatorSettings.enabled is true', async () => {
+        it('should register subagents as tools when agents.overrides.codebase_investigator.enabled is true', async () => {
             const params = {
                 ...baseParams,
-                codebaseInvestigatorSettings: { enabled: true },
+                agents: {
+                    overrides: {
+                        codebase_investigator: { enabled: true },
+                    },
+                },
             };
             const config = new Config(params);
             const mockAgentDefinition = {
@@ -727,29 +804,57 @@ describe('Server Config (config.ts)', () => {
             };
             const AgentRegistryMock = (await vi.importMock('../agents/registry.js')).AgentRegistry;
             AgentRegistryMock.prototype.getDefinition.mockReturnValue(mockAgentDefinition);
-            const DelegateToAgentToolMock = (await vi.importMock('../agents/delegate-to-agent-tool.js')).DelegateToAgentTool;
+            AgentRegistryMock.prototype.getAllDefinitions.mockReturnValue([
+                mockAgentDefinition,
+            ]);
+            const SubAgentToolMock = (await vi.importMock('../agents/subagent-tool.js')).SubagentTool;
             await config.initialize();
             const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
-            expect(DelegateToAgentToolMock).toHaveBeenCalledTimes(1);
-            expect(DelegateToAgentToolMock).toHaveBeenCalledWith(expect.anything(), // AgentRegistry
+            expect(SubAgentToolMock).toHaveBeenCalledTimes(1);
+            expect(SubAgentToolMock).toHaveBeenCalledWith(expect.anything(), // AgentRegistry
             config, expect.anything());
             const calls = registerToolMock.mock.calls;
-            const registeredWrappers = calls.filter((call) => call[0] instanceof DelegateToAgentToolMock);
+            const registeredWrappers = calls.filter((call) => call[0] instanceof SubAgentToolMock);
             expect(registeredWrappers).toHaveLength(1);
         });
-        it('should not register subagents as tools when codebaseInvestigatorSettings.enabled is false', async () => {
+        it('should register subagents as tools even when they are not in allowedTools', async () => {
             const params = {
                 ...baseParams,
-                codebaseInvestigatorSettings: { enabled: false },
+                allowedTools: ['read_file'], // codebase-investigator is NOT here
+                agents: {
+                    overrides: {
+                        codebase_investigator: { enabled: true },
+                    },
+                },
             };
             const config = new Config(params);
-            const DelegateToAgentToolMock = (await vi.importMock('../agents/delegate-to-agent-tool.js')).DelegateToAgentTool;
+            const mockAgentDefinition = {
+                name: 'codebase-investigator',
+                description: 'Agent 1',
+                instructions: 'Inst 1',
+            };
+            const AgentRegistryMock = (await vi.importMock('../agents/registry.js')).AgentRegistry;
+            AgentRegistryMock.prototype.getAllDefinitions.mockReturnValue([
+                mockAgentDefinition,
+            ]);
+            const SubAgentToolMock = (await vi.importMock('../agents/subagent-tool.js')).SubagentTool;
             await config.initialize();
-            expect(DelegateToAgentToolMock).not.toHaveBeenCalled();
+            expect(SubAgentToolMock).toHaveBeenCalled();
         });
-        it('should not set default codebase investigator model in config (defaults in registry)', () => {
-            const config = new Config(baseParams);
-            expect(config.getCodebaseInvestigatorSettings()?.model).toBeUndefined();
+        it('should not register subagents as tools when agents are disabled', async () => {
+            const params = {
+                ...baseParams,
+                agents: {
+                    overrides: {
+                        codebase_investigator: { enabled: false },
+                        cli_help: { enabled: false },
+                    },
+                },
+            };
+            const config = new Config(params);
+            const SubAgentToolMock = (await vi.importMock('../agents/subagent-tool.js')).SubagentTool;
+            await config.initialize();
+            expect(SubAgentToolMock).not.toHaveBeenCalled();
         });
         describe('with minified tool class names', () => {
             beforeEach(() => {
@@ -796,16 +901,16 @@ describe('Server Config (config.ts)', () => {
             vi.mocked(tokenLimit).mockReturnValue(32000);
             vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(1000);
             // 4 * (32000 - 1000) = 4 * 31000 = 124000
-            // default is 4_000_000
-            expect(config.getTruncateToolOutputThreshold()).toBe(124000);
+            // default is 40_000, so min(124000, 40000) = 40000
+            expect(config.getTruncateToolOutputThreshold()).toBe(40_000);
         });
         it('should return the default threshold when the calculated value is larger', () => {
             const config = new Config(baseParams);
             vi.mocked(tokenLimit).mockReturnValue(2_000_000);
             vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(500_000);
             // 4 * (2_000_000 - 500_000) = 4 * 1_500_000 = 6_000_000
-            // default is 4_000_000
-            expect(config.getTruncateToolOutputThreshold()).toBe(4_000_000);
+            // default is 40_000
+            expect(config.getTruncateToolOutputThreshold()).toBe(40_000);
         });
         it('should use a custom truncateToolOutputThreshold if provided', () => {
             const customParams = {
@@ -903,15 +1008,49 @@ describe('setApprovalMode with folder trust', () => {
         expect(() => config.setApprovalMode(ApprovalMode.AUTO_EDIT)).not.toThrow();
         expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
     });
+    it('should update system instruction when entering Plan mode', () => {
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue({
+            getTool: vi.fn().mockReturnValue(undefined),
+            unregisterTool: vi.fn(),
+            registerTool: vi.fn(),
+        });
+        const updateSpy = vi.spyOn(config, 'updateSystemInstructionIfInitialized');
+        config.setApprovalMode(ApprovalMode.PLAN);
+        expect(updateSpy).toHaveBeenCalled();
+    });
+    it('should update system instruction when leaving Plan mode', () => {
+        const config = new Config({
+            ...baseParams,
+            approvalMode: ApprovalMode.PLAN,
+        });
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue({
+            getTool: vi.fn().mockReturnValue(undefined),
+            unregisterTool: vi.fn(),
+            registerTool: vi.fn(),
+        });
+        const updateSpy = vi.spyOn(config, 'updateSystemInstructionIfInitialized');
+        config.setApprovalMode(ApprovalMode.DEFAULT);
+        expect(updateSpy).toHaveBeenCalled();
+    });
+    it('should not update system instruction when switching between non-Plan modes', () => {
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+        const updateSpy = vi.spyOn(config, 'updateSystemInstructionIfInitialized');
+        config.setApprovalMode(ApprovalMode.AUTO_EDIT);
+        expect(updateSpy).not.toHaveBeenCalled();
+    });
     describe('registerCoreTools', () => {
         beforeEach(() => {
             vi.clearAllMocks();
         });
         it('should register RipGrepTool when useRipgrep is true and it is available', async () => {
-            canUseRipgrep.mockResolvedValue(true);
+            vi.mocked(canUseRipgrep).mockResolvedValue(true);
             const config = new Config({ ...baseParams, useRipgrep: true });
             await config.initialize();
-            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const calls = vi.mocked(ToolRegistry.prototype.registerTool).mock.calls;
             const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
             const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
             expect(wasRipGrepRegistered).toBe(true);
@@ -919,36 +1058,36 @@ describe('setApprovalMode with folder trust', () => {
             expect(logRipgrepFallback).not.toHaveBeenCalled();
         });
         it('should register GrepTool as a fallback when useRipgrep is true but it is not available', async () => {
-            canUseRipgrep.mockResolvedValue(false);
+            vi.mocked(canUseRipgrep).mockResolvedValue(false);
             const config = new Config({ ...baseParams, useRipgrep: true });
             await config.initialize();
-            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const calls = vi.mocked(ToolRegistry.prototype.registerTool).mock.calls;
             const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
             const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
             expect(wasRipGrepRegistered).toBe(false);
             expect(wasGrepRegistered).toBe(true);
             expect(logRipgrepFallback).toHaveBeenCalledWith(config, expect.any(RipgrepFallbackEvent));
-            const event = logRipgrepFallback.mock.calls[0][1];
+            const event = vi.mocked(logRipgrepFallback).mock.calls[0][1];
             expect(event.error).toBeUndefined();
         });
         it('should register GrepTool as a fallback when canUseRipgrep throws an error', async () => {
             const error = new Error('ripGrep check failed');
-            canUseRipgrep.mockRejectedValue(error);
+            vi.mocked(canUseRipgrep).mockRejectedValue(error);
             const config = new Config({ ...baseParams, useRipgrep: true });
             await config.initialize();
-            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const calls = vi.mocked(ToolRegistry.prototype.registerTool).mock.calls;
             const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
             const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
             expect(wasRipGrepRegistered).toBe(false);
             expect(wasGrepRegistered).toBe(true);
             expect(logRipgrepFallback).toHaveBeenCalledWith(config, expect.any(RipgrepFallbackEvent));
-            const event = logRipgrepFallback.mock.calls[0][1];
+            const event = vi.mocked(logRipgrepFallback).mock.calls[0][1];
             expect(event.error).toBe(String(error));
         });
         it('should register GrepTool when useRipgrep is false', async () => {
             const config = new Config({ ...baseParams, useRipgrep: false });
             await config.initialize();
-            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const calls = vi.mocked(ToolRegistry.prototype.registerTool).mock.calls;
             const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
             const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
             expect(wasRipGrepRegistered).toBe(false);
@@ -1069,7 +1208,6 @@ describe('Generation Config Merging (HACK)', () => {
             },
         };
         const config = new Config(params);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const serviceConfig = config.modelConfigService.config;
         // Assert that the default aliases are present
         expect(serviceConfig.aliases).toEqual(DEFAULT_MODEL_CONFIGS.aliases);
@@ -1089,7 +1227,6 @@ describe('Generation Config Merging (HACK)', () => {
             },
         };
         const config = new Config(params);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const serviceConfig = config.modelConfigService.config;
         // Assert that the user's aliases are present
         expect(serviceConfig.aliases).toEqual(userAliases);
@@ -1109,7 +1246,6 @@ describe('Generation Config Merging (HACK)', () => {
             },
         };
         const config = new Config(params);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const serviceConfig = config.modelConfigService.config;
         // Assert that the user's aliases are used, not the defaults
         expect(serviceConfig.aliases).toEqual(userAliases);
@@ -1117,7 +1253,6 @@ describe('Generation Config Merging (HACK)', () => {
     it('should use default generation config if none is provided', () => {
         const params = { ...baseParams };
         const config = new Config(params);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const serviceConfig = config.modelConfigService.config;
         // Assert that the full default config is used
         expect(serviceConfig).toEqual(DEFAULT_MODEL_CONFIGS);
@@ -1145,37 +1280,15 @@ describe('Config getHooks', () => {
     });
     it('should return the hooks configuration when provided', () => {
         const mockHooks = {
-            [HookEventName.BeforeTool]: [
-                {
-                    matcher: 'write_file',
-                    hooks: [
-                        {
-                            type: HookType.Command,
-                            command: 'echo "test hook"',
-                            timeout: 5000,
-                        },
-                    ],
-                },
-            ],
-            [HookEventName.AfterTool]: [
+            BeforeTool: [
                 {
-                    hooks: [
-                        {
-                            type: HookType.Command,
-                            command: './hooks/after-tool.sh',
-                            timeout: 10000,
-                        },
-                    ],
+                    hooks: [{ type: HookType.Command, command: 'echo 1' }],
                 },
             ],
         };
-        const config = new Config({
-            ...baseParams,
-            hooks: mockHooks,
-        });
+        const config = new Config({ ...baseParams, hooks: mockHooks });
         const retrievedHooks = config.getHooks();
         expect(retrievedHooks).toEqual(mockHooks);
-        expect(retrievedHooks).toBe(mockHooks); // Should return the same reference
     });
     it('should return hooks with all supported event types', () => {
         const allEventHooks = {
@@ -1409,9 +1522,38 @@ describe('Availability Service Integration', () => {
         expect(spy).toHaveBeenCalled();
     });
 });
+describe('Hooks configuration', () => {
+    const baseParams = {
+        sessionId: 'test',
+        targetDir: '.',
+        debugMode: false,
+        model: 'test-model',
+        cwd: '.',
+        disabledHooks: ['initial-hook'],
+    };
+    it('updateDisabledHooks should update the disabled list', () => {
+        const config = new Config(baseParams);
+        expect(config.getDisabledHooks()).toEqual(['initial-hook']);
+        const newDisabled = ['new-hook-1', 'new-hook-2'];
+        config.updateDisabledHooks(newDisabled);
+        expect(config.getDisabledHooks()).toEqual(['new-hook-1', 'new-hook-2']);
+    });
+    it('updateDisabledHooks should only update disabled list and not definitions', () => {
+        const initialHooks = {
+            BeforeAgent: [
+                {
+                    hooks: [{ type: HookType.Command, command: 'initial' }],
+                },
+            ],
+        };
+        const config = new Config({ ...baseParams, hooks: initialHooks });
+        config.updateDisabledHooks(['some-hook']);
+        expect(config.getDisabledHooks()).toEqual(['some-hook']);
+        expect(config.getHooks()).toEqual(initialHooks);
+    });
+});
 describe('Config Quota & Preview Model Access', () => {
     let config;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let mockCodeAssistServer;
     const baseParams = {
         cwd: '/tmp',
@@ -1438,18 +1580,82 @@ describe('Config Quota & Preview Model Access', () => {
     describe('refreshUserQuota', () => {
         it('should update hasAccessToPreviewModel to true if quota includes preview model', async () => {
             mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
-                buckets: [{ modelId: PREVIEW_GEMINI_MODEL }],
+                buckets: [
+                    {
+                        modelId: 'gemini-3-pro-preview',
+                        remainingAmount: '100',
+                        remainingFraction: 1.0,
+                    },
+                ],
+            });
+            await config.refreshUserQuota();
+            expect(config.getHasAccessToPreviewModel()).toBe(true);
+        });
+        it('should update hasAccessToPreviewModel to true if quota includes Gemini 3.1 preview model', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [
+                    {
+                        modelId: 'gemini-3.1-pro-preview',
+                        remainingAmount: '100',
+                        remainingFraction: 1.0,
+                    },
+                ],
             });
             await config.refreshUserQuota();
             expect(config.getHasAccessToPreviewModel()).toBe(true);
         });
         it('should update hasAccessToPreviewModel to false if quota does not include preview model', async () => {
             mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
-                buckets: [{ modelId: 'some-other-model' }],
+                buckets: [
+                    {
+                        modelId: 'some-other-model',
+                        remainingAmount: '10',
+                        remainingFraction: 0.1,
+                    },
+                ],
             });
             await config.refreshUserQuota();
             expect(config.getHasAccessToPreviewModel()).toBe(false);
         });
+        it('should calculate pooled quota correctly for auto models', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [
+                    {
+                        modelId: 'gemini-2.5-pro',
+                        remainingAmount: '10',
+                        remainingFraction: 0.2,
+                    },
+                    {
+                        modelId: 'gemini-2.5-flash',
+                        remainingAmount: '80',
+                        remainingFraction: 0.8,
+                    },
+                ],
+            });
+            config.setModel('auto-gemini-2.5');
+            await config.refreshUserQuota();
+            const pooled = config.getPooledQuota();
+            // Pro: 10 / 0.2 = 50 total.
+            // Flash: 80 / 0.8 = 100 total.
+            // Pooled: (10 + 80) / (50 + 100) = 90 / 150 = 0.6
+            expect(pooled?.remaining).toBe(90);
+            expect(pooled?.limit).toBe(150);
+            expect((pooled?.remaining ?? 0) / (pooled?.limit ?? 1)).toBeCloseTo(0.6);
+        });
+        it('should return undefined pooled quota for non-auto models', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [
+                    {
+                        modelId: 'gemini-2.5-pro',
+                        remainingAmount: '10',
+                        remainingFraction: 0.2,
+                    },
+                ],
+            });
+            config.setModel('gemini-2.5-pro');
+            await config.refreshUserQuota();
+            expect(config.getPooledQuota()).toEqual({});
+        });
         it('should update hasAccessToPreviewModel to false if buckets are undefined', async () => {
             mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({});
             await config.refreshUserQuota();
@@ -1469,31 +1675,97 @@ describe('Config Quota & Preview Model Access', () => {
             expect(config.getHasAccessToPreviewModel()).toBe(false);
         });
     });
-    describe('setPreviewFeatures', () => {
-        it('should reset model to default auto if disabling preview features while using a preview model', () => {
-            config.setPreviewFeatures(true);
-            config.setModel(PREVIEW_GEMINI_MODEL);
-            config.setPreviewFeatures(false);
-            expect(config.getModel()).toBe(DEFAULT_GEMINI_MODEL_AUTO);
+    describe('refreshUserQuotaIfStale', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date('2025-01-01T00:00:00Z'));
+        });
+        afterEach(() => {
+            vi.useRealTimers();
         });
-        it('should NOT reset model if disabling preview features while NOT using a preview model', () => {
-            config.setPreviewFeatures(true);
-            const nonPreviewModel = 'gemini-1.5-pro';
-            config.setModel(nonPreviewModel);
-            config.setPreviewFeatures(false);
-            expect(config.getModel()).toBe(nonPreviewModel);
+        it('should refresh quota if stale', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [],
+            });
+            // First call to initialize lastQuotaFetchTime
+            await config.refreshUserQuota();
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(1);
+            // Advance time by 31 seconds (default TTL is 30s)
+            vi.setSystemTime(Date.now() + 31_000);
+            await config.refreshUserQuotaIfStale();
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(2);
         });
-        it('should switch to preview auto model if enabling preview features while using default auto model', () => {
-            config.setPreviewFeatures(false);
-            config.setModel(DEFAULT_GEMINI_MODEL_AUTO);
-            config.setPreviewFeatures(true);
-            expect(config.getModel()).toBe(PREVIEW_GEMINI_MODEL_AUTO);
+        it('should not refresh quota if fresh', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [],
+            });
+            // First call
+            await config.refreshUserQuota();
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(1);
+            // Advance time by only 10 seconds
+            vi.setSystemTime(Date.now() + 10_000);
+            await config.refreshUserQuotaIfStale();
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(1);
+        });
+        it('should respect custom staleMs', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [],
+            });
+            // First call
+            await config.refreshUserQuota();
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(1);
+            // Advance time by 5 seconds
+            vi.setSystemTime(Date.now() + 5_000);
+            // Refresh with 2s staleMs -> should refresh
+            await config.refreshUserQuotaIfStale(2_000);
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(2);
+            // Advance by another 5 seconds
+            vi.setSystemTime(Date.now() + 5_000);
+            // Refresh with 10s staleMs -> should NOT refresh
+            await config.refreshUserQuotaIfStale(10_000);
+            expect(mockCodeAssistServer.retrieveUserQuota).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('getUserTier and getUserTierName', () => {
+        it('should return undefined if contentGenerator is not initialized', () => {
+            const config = new Config(baseParams);
+            expect(config.getUserTier()).toBeUndefined();
+            expect(config.getUserTierName()).toBeUndefined();
         });
-        it('should NOT reset model if enabling preview features', () => {
-            config.setPreviewFeatures(false);
-            config.setModel(PREVIEW_GEMINI_MODEL); // Just pretending it was set somehow
-            config.setPreviewFeatures(true);
-            expect(config.getModel()).toBe(PREVIEW_GEMINI_MODEL);
+        it('should return values from contentGenerator after refreshAuth', async () => {
+            const config = new Config(baseParams);
+            const mockTier = UserTierId.STANDARD;
+            const mockTierName = 'Standard Tier';
+            vi.mocked(createContentGeneratorConfig).mockResolvedValue({
+                authType: AuthType.USE_GEMINI,
+            });
+            vi.mocked(createContentGenerator).mockResolvedValue({
+                userTier: mockTier,
+                userTierName: mockTierName,
+            });
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            expect(config.getUserTier()).toBe(mockTier);
+            expect(config.getUserTierName()).toBe(mockTierName);
+        });
+    });
+    describe('isPlanEnabled', () => {
+        it('should return false by default', () => {
+            const config = new Config(baseParams);
+            expect(config.isPlanEnabled()).toBe(false);
+        });
+        it('should return true when plan is enabled', () => {
+            const config = new Config({
+                ...baseParams,
+                plan: true,
+            });
+            expect(config.isPlanEnabled()).toBe(true);
+        });
+        it('should return false when plan is explicitly disabled', () => {
+            const config = new Config({
+                ...baseParams,
+                plan: false,
+            });
+            expect(config.isPlanEnabled()).toBe(false);
         });
     });
 });
@@ -1505,6 +1777,7 @@ describe('Config JIT Initialization', () => {
         mockContextManager = {
             refresh: vi.fn(),
             getGlobalMemory: vi.fn().mockReturnValue('Global Memory'),
+            getExtensionMemory: vi.fn().mockReturnValue('Extension Memory'),
             getEnvironmentMemory: vi
                 .fn()
                 .mockReturnValue('Environment Memory\n\nMCP Instructions'),
@@ -1526,7 +1799,11 @@ describe('Config JIT Initialization', () => {
         await config.initialize();
         expect(ContextManager).toHaveBeenCalledWith(config);
         expect(mockContextManager.refresh).toHaveBeenCalled();
-        expect(config.getUserMemory()).toBe('Global Memory\n\nEnvironment Memory\n\nMCP Instructions');
+        expect(config.getUserMemory()).toEqual({
+            global: 'Global Memory',
+            extension: 'Extension Memory',
+            project: 'Environment Memory\n\nMCP Instructions',
+        });
         // Verify state update (delegated to ContextManager)
         expect(config.getGeminiMdFileCount()).toBe(1);
         expect(config.getGeminiMdFilePaths()).toEqual(['/path/to/GEMINI.md']);
@@ -1574,7 +1851,7 @@ describe('Config JIT Initialization', () => {
             expect(mockOnReload).toHaveBeenCalled();
             expect(skillManager.setDisabledSkills).toHaveBeenCalledWith(['skill2']);
             expect(toolRegistry.registerTool).toHaveBeenCalled();
-            expect(toolRegistry.unregisterTool).not.toHaveBeenCalledWith(ACTIVATE_SKILL_TOOL_NAME);
+            expect(toolRegistry.unregisterTool).toHaveBeenCalledWith(ACTIVATE_SKILL_TOOL_NAME);
         });
         it('should unregister ActivateSkillTool when no skills exist after reload', async () => {
             const params = {
@@ -1620,6 +1897,148 @@ describe('Config JIT Initialization', () => {
             await config.reloadSkills();
             expect(skillManager.setDisabledSkills).toHaveBeenCalledWith([]);
         });
+        it('should update admin settings from onReload', async () => {
+            const mockOnReload = vi.fn().mockResolvedValue({
+                adminSkillsEnabled: false,
+            });
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                skillsSupport: true,
+                onReload: mockOnReload,
+            };
+            config = new Config(params);
+            await config.initialize();
+            const skillManager = config.getSkillManager();
+            vi.spyOn(skillManager, 'setAdminSettings');
+            await config.reloadSkills();
+            expect(skillManager.setAdminSettings).toHaveBeenCalledWith(false);
+        });
+    });
+});
+describe('Plans Directory Initialization', () => {
+    const baseParams = {
+        sessionId: 'test-session',
+        targetDir: '/tmp/test',
+        debugMode: false,
+        model: 'test-model',
+        cwd: '/tmp/test',
+    };
+    beforeEach(() => {
+        vi.spyOn(fs.promises, 'mkdir').mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.mocked(fs.promises.mkdir).mockRestore();
+    });
+    it('should create plans directory and add it to workspace context when plan is enabled', async () => {
+        const config = new Config({
+            ...baseParams,
+            plan: true,
+        });
+        await config.initialize();
+        const plansDir = config.storage.getProjectTempPlansDir();
+        expect(fs.promises.mkdir).toHaveBeenCalledWith(plansDir, {
+            recursive: true,
+        });
+        const context = config.getWorkspaceContext();
+        expect(context.getDirectories()).toContain(plansDir);
+    });
+    it('should NOT create plans directory or add it to workspace context when plan is disabled', async () => {
+        const config = new Config({
+            ...baseParams,
+            plan: false,
+        });
+        await config.initialize();
+        const plansDir = config.storage.getProjectTempPlansDir();
+        expect(fs.promises.mkdir).not.toHaveBeenCalledWith(plansDir, {
+            recursive: true,
+        });
+        const context = config.getWorkspaceContext();
+        expect(context.getDirectories()).not.toContain(plansDir);
+    });
+});
+describe('syncPlanModeTools', () => {
+    const baseParams = {
+        sessionId: 'test-session',
+        targetDir: '.',
+        debugMode: false,
+        model: 'test-model',
+        cwd: '.',
+    };
+    it('should register ExitPlanModeTool and unregister EnterPlanModeTool when in PLAN mode', async () => {
+        const config = new Config({
+            ...baseParams,
+            approvalMode: ApprovalMode.PLAN,
+        });
+        const registry = new ToolRegistry(config, config.getMessageBus());
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue(registry);
+        const registerSpy = vi.spyOn(registry, 'registerTool');
+        const unregisterSpy = vi.spyOn(registry, 'unregisterTool');
+        const getToolSpy = vi.spyOn(registry, 'getTool');
+        getToolSpy.mockImplementation((name) => {
+            if (name === 'enter_plan_mode')
+                return new EnterPlanModeTool(config, config.getMessageBus());
+            return undefined;
+        });
+        config.syncPlanModeTools();
+        expect(unregisterSpy).toHaveBeenCalledWith('enter_plan_mode');
+        expect(registerSpy).toHaveBeenCalledWith(expect.anything());
+        const registeredTool = registerSpy.mock.calls[0][0];
+        const { ExitPlanModeTool } = await import('../tools/exit-plan-mode.js');
+        expect(registeredTool).toBeInstanceOf(ExitPlanModeTool);
+    });
+    it('should register EnterPlanModeTool and unregister ExitPlanModeTool when NOT in PLAN mode and experimental.plan is enabled', async () => {
+        const config = new Config({
+            ...baseParams,
+            approvalMode: ApprovalMode.DEFAULT,
+            plan: true,
+        });
+        const registry = new ToolRegistry(config, config.getMessageBus());
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue(registry);
+        const registerSpy = vi.spyOn(registry, 'registerTool');
+        const unregisterSpy = vi.spyOn(registry, 'unregisterTool');
+        const getToolSpy = vi.spyOn(registry, 'getTool');
+        getToolSpy.mockImplementation((name) => {
+            if (name === 'exit_plan_mode')
+                return new ExitPlanModeTool(config, config.getMessageBus());
+            return undefined;
+        });
+        config.syncPlanModeTools();
+        expect(unregisterSpy).toHaveBeenCalledWith('exit_plan_mode');
+        expect(registerSpy).toHaveBeenCalledWith(expect.anything());
+        const registeredTool = registerSpy.mock.calls[0][0];
+        const { EnterPlanModeTool } = await import('../tools/enter-plan-mode.js');
+        expect(registeredTool).toBeInstanceOf(EnterPlanModeTool);
+    });
+    it('should NOT register EnterPlanModeTool when experimental.plan is disabled', async () => {
+        const config = new Config({
+            ...baseParams,
+            approvalMode: ApprovalMode.DEFAULT,
+            plan: false,
+        });
+        const registry = new ToolRegistry(config, config.getMessageBus());
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue(registry);
+        const registerSpy = vi.spyOn(registry, 'registerTool');
+        vi.spyOn(registry, 'getTool').mockReturnValue(undefined);
+        config.syncPlanModeTools();
+        const { EnterPlanModeTool } = await import('../tools/enter-plan-mode.js');
+        const registeredTool = registerSpy.mock.calls.find((call) => call[0] instanceof EnterPlanModeTool);
+        expect(registeredTool).toBeUndefined();
+    });
+    it('should call geminiClient.setTools if initialized', async () => {
+        const config = new Config(baseParams);
+        const registry = new ToolRegistry(config, config.getMessageBus());
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue(registry);
+        const client = config.getGeminiClient();
+        vi.spyOn(client, 'isInitialized').mockReturnValue(true);
+        const setToolsSpy = vi
+            .spyOn(client, 'setTools')
+            .mockResolvedValue(undefined);
+        config.syncPlanModeTools();
+        expect(setToolsSpy).toHaveBeenCalled();
     });
 });
 //# sourceMappingURL=config.test.js.map