@office-ai/aioncli-core 0.18.6 → 0.24.0-preview.1

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

@@ -22,7 +22,9 @@ import { RipGrepTool, canUseRipgrep } from '../tools/ripGrep.js';
 import { logRipgrepFallback } from '../telemetry/loggers.js';
 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';
 vi.mock('fs', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -38,6 +40,7 @@ vi.mock('fs', async (importOriginal) => {
 vi.mock('../tools/tool-registry', () => {
     const ToolRegistryMock = vi.fn();
     ToolRegistryMock.prototype.registerTool = vi.fn();
+    ToolRegistryMock.prototype.unregisterTool = vi.fn();
     ToolRegistryMock.prototype.discoverAllTools = vi.fn();
     ToolRegistryMock.prototype.sortTools = vi.fn();
     ToolRegistryMock.prototype.getAllTools = vi.fn(() => []); // Mock methods if needed
@@ -45,6 +48,12 @@ vi.mock('../tools/tool-registry', () => {
     ToolRegistryMock.prototype.getFunctionDeclarations = vi.fn(() => []);
     return { ToolRegistry: ToolRegistryMock };
 });
+vi.mock('../tools/mcp-client-manager.js', () => ({
+    McpClientManager: vi.fn().mockImplementation(() => ({
+        startConfiguredMcpServers: vi.fn(),
+        getMcpInstructions: vi.fn().mockReturnValue('MCP Instructions'),
+    })),
+}));
 vi.mock('../utils/memoryDiscovery.js', () => ({
     loadServerHierarchicalMemory: vi.fn(),
 }));
@@ -75,6 +84,7 @@ vi.mock('../core/client.js', () => ({
     GeminiClient: vi.fn().mockImplementation(() => ({
         initialize: vi.fn().mockResolvedValue(undefined),
         stripThoughtsFromHistory: vi.fn(),
+        isInitialized: vi.fn().mockReturnValue(false),
     })),
 }));
 vi.mock('../telemetry/index.js', async (importOriginal) => {
@@ -115,8 +125,11 @@ vi.mock('../agents/registry.js', () => {
     AgentRegistryMock.prototype.getDefinition = vi.fn();
     return { AgentRegistry: AgentRegistryMock };
 });
-vi.mock('../agents/subagent-tool-wrapper.js', () => ({
-    SubagentToolWrapper: vi.fn(),
+vi.mock('../agents/delegate-to-agent-tool.js', () => ({
+    DelegateToAgentTool: vi.fn(),
+}));
+vi.mock('../resources/resource-registry.js', () => ({
+    ResourceRegistry: vi.fn(),
 }));
 const mockCoreEvents = vi.hoisted(() => ({
     emitFeedback: vi.fn(),
@@ -130,11 +143,13 @@ vi.mock('../utils/events.js', () => ({
 vi.mock('../utils/fetch.js', () => ({
     setGlobalProxy: mockSetGlobalProxy,
 }));
+vi.mock('../services/contextManager.js');
 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';
 vi.mock('../core/baseLlmClient.js');
 vi.mock('../core/tokenLimits.js', () => ({
     tokenLimit: vi.fn(),
@@ -142,7 +157,7 @@ vi.mock('../core/tokenLimits.js', () => ({
 vi.mock('../code_assist/codeAssist.js');
 vi.mock('../code_assist/experiments/experiments.js');
 describe('Server Config (config.ts)', () => {
-    const MODEL = 'gemini-pro';
+    const MODEL = DEFAULT_GEMINI_MODEL;
     const SANDBOX = {
         command: 'docker',
         image: 'gemini-cli-sandbox',
@@ -280,16 +295,19 @@ describe('Server Config (config.ts)', () => {
                 apiKey: 'test-key',
             };
             vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
-            // Set fallback mode to true to ensure it gets reset
-            config.setFallbackMode(true);
-            expect(config.isInFallbackMode()).toBe(true);
             await config.refreshAuth(authType);
             expect(createContentGeneratorConfig).toHaveBeenCalledWith(config, authType);
             // Verify that contentGeneratorConfig is updated
             expect(config.getContentGeneratorConfig()).toEqual(mockContentConfig);
             expect(GeminiClient).toHaveBeenCalledWith(config);
-            // Verify that fallback mode is reset
-            expect(config.isInFallbackMode()).toBe(false);
+        });
+        it('should reset model availability status', async () => {
+            const config = new Config(baseParams);
+            const service = config.getModelAvailabilityService();
+            const spy = vi.spyOn(service, 'reset');
+            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);
@@ -613,83 +631,48 @@ describe('Server Config (config.ts)', () => {
             expect(config.getUseRipgrep()).toBe(true);
         });
     });
-    describe('Model Router with Auth', () => {
-        it('should disable model router by default for oauth-personal', async () => {
-            const config = new Config({
-                ...baseParams,
-                useModelRouter: true,
-            });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getUseModelRouter()).toBe(true);
-        });
-        it('should enable model router by default for other auth types', async () => {
-            const config = new Config({
-                ...baseParams,
-                useModelRouter: true,
-            });
-            await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(config.getUseModelRouter()).toBe(true);
-        });
-        it('should disable model router for specified auth type', async () => {
-            const config = new Config({
-                ...baseParams,
-                useModelRouter: true,
-                disableModelRouterForAuth: [AuthType.USE_GEMINI],
-            });
-            await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(config.getUseModelRouter()).toBe(false);
+    describe('UseWriteTodos Configuration', () => {
+        it('should default useWriteTodos to true when not provided', () => {
+            const config = new Config(baseParams);
+            expect(config.getUseWriteTodos()).toBe(true);
         });
-        it('should enable model router for other auth type', async () => {
-            const config = new Config({
+        it('should set useWriteTodos to false when provided as false', () => {
+            const params = {
                 ...baseParams,
-                useModelRouter: true,
-                disableModelRouterForAuth: [],
-            });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getUseModelRouter()).toBe(true);
+                useWriteTodos: false,
+            };
+            const config = new Config(params);
+            expect(config.getUseWriteTodos()).toBe(false);
         });
-        it('should keep model router disabled when useModelRouter is false', async () => {
-            const config = new Config({
+        it('should disable useWriteTodos for preview models', () => {
+            const params = {
                 ...baseParams,
-                useModelRouter: false,
-                disableModelRouterForAuth: [AuthType.USE_GEMINI],
-            });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getUseModelRouter()).toBe(false);
+                model: 'gemini-3-pro-preview',
+            };
+            const config = new Config(params);
+            expect(config.getUseWriteTodos()).toBe(false);
         });
-        it('should keep the user-chosen model after refreshAuth, even when model router is disabled for the auth type', async () => {
-            const config = new Config({
+        it('should NOT disable useWriteTodos for non-preview models', () => {
+            const params = {
                 ...baseParams,
-                useModelRouter: true,
-                disableModelRouterForAuth: [AuthType.USE_GEMINI],
-            });
-            const chosenModel = 'gemini-1.5-pro-latest';
-            config.setModel(chosenModel);
-            await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(config.getUseModelRouter()).toBe(false);
-            expect(config.getModel()).toBe(chosenModel);
+                model: 'gemini-2.5-pro',
+            };
+            const config = new Config(params);
+            expect(config.getUseWriteTodos()).toBe(true);
         });
-        it('should keep the user-chosen model after refreshAuth, when model router is enabled for the auth type', async () => {
-            const config = new Config({
-                ...baseParams,
-                useModelRouter: true,
-                disableModelRouterForAuth: [AuthType.USE_GEMINI],
-            });
-            const chosenModel = 'gemini-1.5-pro-latest';
-            config.setModel(chosenModel);
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getUseModelRouter()).toBe(true);
-            expect(config.getModel()).toBe(chosenModel);
+    });
+    describe('Shell Tool Inactivity Timeout', () => {
+        it('should default to 300000ms (300 seconds) when not provided', () => {
+            const config = new Config(baseParams);
+            expect(config.getShellToolInactivityTimeout()).toBe(300000);
         });
-        it('should NOT switch to auto model if cli provides specific model, even if router is enabled', async () => {
-            const config = new Config({
+        it('should convert provided seconds to milliseconds', () => {
+            const params = {
                 ...baseParams,
-                useModelRouter: true,
-                model: 'gemini-flash-latest',
-            });
-            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(config.getUseModelRouter()).toBe(true);
-            expect(config.getModel()).toBe('gemini-flash-latest');
+                shellToolInactivityTimeout: 10, // 10 seconds
+            };
+            const config = new Config(params);
+            expect(config.getShellToolInactivityTimeout()).toBe(10000);
         });
     });
     describe('ContinueOnFailedApiCall Configuration', () => {
@@ -744,13 +727,14 @@ describe('Server Config (config.ts)', () => {
             };
             const AgentRegistryMock = (await vi.importMock('../agents/registry.js')).AgentRegistry;
             AgentRegistryMock.prototype.getDefinition.mockReturnValue(mockAgentDefinition);
-            const SubagentToolWrapperMock = (await vi.importMock('../agents/subagent-tool-wrapper.js')).SubagentToolWrapper;
+            const DelegateToAgentToolMock = (await vi.importMock('../agents/delegate-to-agent-tool.js')).DelegateToAgentTool;
             await config.initialize();
             const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
-            expect(SubagentToolWrapperMock).toHaveBeenCalledTimes(1);
-            expect(SubagentToolWrapperMock).toHaveBeenCalledWith(mockAgentDefinition, config, undefined);
+            expect(DelegateToAgentToolMock).toHaveBeenCalledTimes(1);
+            expect(DelegateToAgentToolMock).toHaveBeenCalledWith(expect.anything(), // AgentRegistry
+            config, expect.anything());
             const calls = registerToolMock.mock.calls;
-            const registeredWrappers = calls.filter((call) => call[0] instanceof SubagentToolWrapperMock);
+            const registeredWrappers = calls.filter((call) => call[0] instanceof DelegateToAgentToolMock);
             expect(registeredWrappers).toHaveLength(1);
         });
         it('should not register subagents as tools when codebaseInvestigatorSettings.enabled is false', async () => {
@@ -759,9 +743,13 @@ describe('Server Config (config.ts)', () => {
                 codebaseInvestigatorSettings: { enabled: false },
             };
             const config = new Config(params);
-            const SubagentToolWrapperMock = (await vi.importMock('../agents/subagent-tool-wrapper.js')).SubagentToolWrapper;
+            const DelegateToAgentToolMock = (await vi.importMock('../agents/delegate-to-agent-tool.js')).DelegateToAgentTool;
             await config.initialize();
-            expect(SubagentToolWrapperMock).not.toHaveBeenCalled();
+            expect(DelegateToAgentToolMock).not.toHaveBeenCalled();
+        });
+        it('should not set default codebase investigator model in config (defaults in registry)', () => {
+            const config = new Config(baseParams);
+            expect(config.getCodebaseInvestigatorSettings()?.model).toBeUndefined();
         });
         describe('with minified tool class names', () => {
             beforeEach(() => {
@@ -1088,6 +1076,26 @@ describe('Generation Config Merging (HACK)', () => {
         // Assert that the user's overrides are present
         expect(serviceConfig.overrides).toEqual(userOverrides);
     });
+    it('should merge default overrides when user provides only aliases', () => {
+        const userAliases = {
+            'my-alias': {
+                modelConfig: { model: 'my-model' },
+            },
+        };
+        const params = {
+            ...baseParams,
+            modelConfigServiceConfig: {
+                aliases: userAliases,
+            },
+        };
+        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);
+        // Assert that the default overrides are present
+        expect(serviceConfig.overrides).toEqual(DEFAULT_MODEL_CONFIGS.overrides);
+    });
     it('should use user-provided aliases if they exist', () => {
         const userAliases = {
             'my-alias': {
@@ -1214,26 +1222,26 @@ describe('Config getHooks', () => {
         expect(Object.keys(retrievedHooks)).toHaveLength(11); // All hook event types
     });
     describe('setModel', () => {
-        it('should allow setting a pro (any) model and disable fallback mode', () => {
+        it('should allow setting a pro (any) model and reset availability', () => {
             const config = new Config(baseParams);
-            config.setFallbackMode(true);
-            expect(config.isInFallbackMode()).toBe(true);
+            const service = config.getModelAvailabilityService();
+            const spy = vi.spyOn(service, 'reset');
             const proModel = 'gemini-2.5-pro';
             config.setModel(proModel);
             expect(config.getModel()).toBe(proModel);
-            expect(config.isInFallbackMode()).toBe(false);
             expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith(proModel);
+            expect(spy).toHaveBeenCalled();
         });
-        it('should allow setting auto model from non-auto model and disable fallback mode', () => {
+        it('should allow setting auto model from non-auto model and reset availability', () => {
             const config = new Config(baseParams);
-            config.setFallbackMode(true);
-            expect(config.isInFallbackMode()).toBe(true);
+            const service = config.getModelAvailabilityService();
+            const spy = vi.spyOn(service, 'reset');
             config.setModel('auto');
             expect(config.getModel()).toBe('auto');
-            expect(config.isInFallbackMode()).toBe(false);
             expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
+            expect(spy).toHaveBeenCalled();
         });
-        it('should allow setting auto model from auto model if it is in the fallback mode', () => {
+        it('should allow setting auto model from auto model and reset availability', () => {
             const config = new Config({
                 cwd: '/tmp',
                 targetDir: '/path/to/target',
@@ -1242,12 +1250,39 @@ describe('Config getHooks', () => {
                 model: 'auto',
                 usageStatisticsEnabled: false,
             });
-            config.setFallbackMode(true);
-            expect(config.isInFallbackMode()).toBe(true);
+            const service = config.getModelAvailabilityService();
+            const spy = vi.spyOn(service, 'reset');
             config.setModel('auto');
             expect(config.getModel()).toBe('auto');
-            expect(config.isInFallbackMode()).toBe(false);
-            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
+            expect(spy).toHaveBeenCalled();
+        });
+        it('should reset active model when setModel is called with the current model after a fallback', () => {
+            const config = new Config(baseParams);
+            const originalModel = config.getModel();
+            const fallbackModel = 'fallback-model';
+            config.setActiveModel(fallbackModel);
+            expect(config.getActiveModel()).toBe(fallbackModel);
+            config.setModel(originalModel);
+            expect(config.getModel()).toBe(originalModel);
+            expect(config.getActiveModel()).toBe(originalModel);
+        });
+        it('should call onModelChange when a new model is set and should persist', () => {
+            const onModelChange = vi.fn();
+            const config = new Config({
+                ...baseParams,
+                onModelChange,
+            });
+            config.setModel(DEFAULT_GEMINI_MODEL, false);
+            expect(onModelChange).toHaveBeenCalledWith(DEFAULT_GEMINI_MODEL);
+        });
+        it('should NOT call onModelChange when a new model is temporary', () => {
+            const onModelChange = vi.fn();
+            const config = new Config({
+                ...baseParams,
+                onModelChange,
+            });
+            config.setModel(DEFAULT_GEMINI_MODEL, true);
+            expect(onModelChange).not.toHaveBeenCalled();
         });
     });
 });
@@ -1344,4 +1379,247 @@ describe('Config setExperiments logging', () => {
         debugSpy.mockRestore();
     });
 });
+describe('Availability Service Integration', () => {
+    const baseModel = 'test-model';
+    const baseParams = {
+        sessionId: 'test',
+        targetDir: '.',
+        debugMode: false,
+        model: baseModel,
+        cwd: '.',
+    };
+    it('setActiveModel updates active model', async () => {
+        const config = new Config(baseParams);
+        const model1 = 'model1';
+        const model2 = 'model2';
+        config.setActiveModel(model1);
+        expect(config.getActiveModel()).toBe(model1);
+        config.setActiveModel(model2);
+        expect(config.getActiveModel()).toBe(model2);
+    });
+    it('getActiveModel defaults to configured model if not set', () => {
+        const config = new Config(baseParams);
+        expect(config.getActiveModel()).toBe(baseModel);
+    });
+    it('resetTurn delegates to availability service', () => {
+        const config = new Config(baseParams);
+        const service = config.getModelAvailabilityService();
+        const spy = vi.spyOn(service, 'resetTurn');
+        config.resetTurn();
+        expect(spy).toHaveBeenCalled();
+    });
+});
+describe('Config Quota & Preview Model Access', () => {
+    let config;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let mockCodeAssistServer;
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/tmp',
+        debugMode: false,
+        sessionId: 'test-session',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+        embeddingModel: 'gemini-embedding',
+        sandbox: {
+            command: 'docker',
+            image: 'gemini-cli-sandbox',
+        },
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockCodeAssistServer = {
+            projectId: 'test-project',
+            retrieveUserQuota: vi.fn(),
+        };
+        vi.mocked(getCodeAssistServer).mockReturnValue(mockCodeAssistServer);
+        config = new Config(baseParams);
+    });
+    describe('refreshUserQuota', () => {
+        it('should update hasAccessToPreviewModel to true if quota includes preview model', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [{ modelId: PREVIEW_GEMINI_MODEL }],
+            });
+            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' }],
+            });
+            await config.refreshUserQuota();
+            expect(config.getHasAccessToPreviewModel()).toBe(false);
+        });
+        it('should update hasAccessToPreviewModel to false if buckets are undefined', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({});
+            await config.refreshUserQuota();
+            expect(config.getHasAccessToPreviewModel()).toBe(false);
+        });
+        it('should return undefined and not update if codeAssistServer is missing', async () => {
+            vi.mocked(getCodeAssistServer).mockReturnValue(undefined);
+            const result = await config.refreshUserQuota();
+            expect(result).toBeUndefined();
+            expect(config.getHasAccessToPreviewModel()).toBe(false);
+        });
+        it('should return undefined if retrieveUserQuota fails', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockRejectedValue(new Error('Network error'));
+            const result = await config.refreshUserQuota();
+            expect(result).toBeUndefined();
+            // Should remain default (false)
+            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);
+        });
+        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 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 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);
+        });
+    });
+});
+describe('Config JIT Initialization', () => {
+    let config;
+    let mockContextManager;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockContextManager = {
+            refresh: vi.fn(),
+            getGlobalMemory: vi.fn().mockReturnValue('Global Memory'),
+            getEnvironmentMemory: vi
+                .fn()
+                .mockReturnValue('Environment Memory\n\nMCP Instructions'),
+            getLoadedPaths: vi.fn().mockReturnValue(new Set(['/path/to/GEMINI.md'])),
+        };
+        ContextManager.mockImplementation(() => mockContextManager);
+    });
+    it('should initialize ContextManager, load memory, and delegate to it when experimentalJitContext is enabled', async () => {
+        const params = {
+            sessionId: 'test-session',
+            targetDir: '/tmp/test',
+            debugMode: false,
+            model: 'test-model',
+            experimentalJitContext: true,
+            userMemory: 'Initial Memory',
+            cwd: '/tmp/test',
+        };
+        config = new Config(params);
+        await config.initialize();
+        expect(ContextManager).toHaveBeenCalledWith(config);
+        expect(mockContextManager.refresh).toHaveBeenCalled();
+        expect(config.getUserMemory()).toBe('Global Memory\n\nEnvironment Memory\n\nMCP Instructions');
+        // Verify state update (delegated to ContextManager)
+        expect(config.getGeminiMdFileCount()).toBe(1);
+        expect(config.getGeminiMdFilePaths()).toEqual(['/path/to/GEMINI.md']);
+    });
+    it('should NOT initialize ContextManager when experimentalJitContext is disabled', async () => {
+        const params = {
+            sessionId: 'test-session',
+            targetDir: '/tmp/test',
+            debugMode: false,
+            model: 'test-model',
+            experimentalJitContext: false,
+            userMemory: 'Initial Memory',
+            cwd: '/tmp/test',
+        };
+        config = new Config(params);
+        await config.initialize();
+        expect(ContextManager).not.toHaveBeenCalled();
+        expect(config.getUserMemory()).toBe('Initial Memory');
+    });
+    describe('reloadSkills', () => {
+        it('should refresh disabledSkills and re-register ActivateSkillTool when skills exist', async () => {
+            const mockOnReload = vi.fn().mockResolvedValue({
+                disabledSkills: ['skill2'],
+            });
+            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();
+            const toolRegistry = config.getToolRegistry();
+            vi.spyOn(skillManager, 'discoverSkills').mockResolvedValue(undefined);
+            vi.spyOn(skillManager, 'setDisabledSkills');
+            vi.spyOn(toolRegistry, 'registerTool');
+            vi.spyOn(toolRegistry, 'unregisterTool');
+            const mockSkills = [{ name: 'skill1' }];
+            vi.spyOn(skillManager, 'getSkills').mockReturnValue(mockSkills);
+            await config.reloadSkills();
+            expect(mockOnReload).toHaveBeenCalled();
+            expect(skillManager.setDisabledSkills).toHaveBeenCalledWith(['skill2']);
+            expect(toolRegistry.registerTool).toHaveBeenCalled();
+            expect(toolRegistry.unregisterTool).not.toHaveBeenCalledWith(ACTIVATE_SKILL_TOOL_NAME);
+        });
+        it('should unregister ActivateSkillTool when no skills exist after reload', async () => {
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                skillsSupport: true,
+            };
+            config = new Config(params);
+            await config.initialize();
+            const skillManager = config.getSkillManager();
+            const toolRegistry = config.getToolRegistry();
+            vi.spyOn(skillManager, 'discoverSkills').mockResolvedValue(undefined);
+            vi.spyOn(toolRegistry, 'registerTool');
+            vi.spyOn(toolRegistry, 'unregisterTool');
+            vi.spyOn(skillManager, 'getSkills').mockReturnValue([]);
+            await config.reloadSkills();
+            expect(toolRegistry.unregisterTool).toHaveBeenCalledWith(ACTIVATE_SKILL_TOOL_NAME);
+        });
+        it('should clear disabledSkills when onReload returns undefined for them', async () => {
+            const mockOnReload = vi.fn().mockResolvedValue({
+                disabledSkills: undefined,
+            });
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                skillsSupport: true,
+                onReload: mockOnReload,
+            };
+            config = new Config(params);
+            // Initially set some disabled skills
+            // @ts-expect-error - accessing private
+            config.disabledSkills = ['skill1'];
+            await config.initialize();
+            const skillManager = config.getSkillManager();
+            vi.spyOn(skillManager, 'discoverSkills').mockResolvedValue(undefined);
+            vi.spyOn(skillManager, 'setDisabledSkills');
+            await config.reloadSkills();
+            expect(skillManager.setDisabledSkills).toHaveBeenCalledWith([]);
+        });
+    });
+});
 //# sourceMappingURL=config.test.js.map