@machina.ai/cell-cli-core 1.20.2-rc1 → 1.25.0-rc1

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

@@ -15,7 +15,6 @@ import { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, } from '../telemetry/i
 import { AuthType, createContentGeneratorConfig, } from '../core/contentGenerator.js';
 import { GeminiClient } from '../core/client.js';
 import { GitService } from '../services/gitService.js';
-import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
 import { ShellTool } from '../tools/shell.js';
 import { ReadFileTool } from '../tools/read-file.js';
 import { GrepTool } from '../tools/grep.js';
@@ -23,16 +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';
-const mockCoreEvents = vi.hoisted(() => ({
-    emit: vi.fn(),
-    emitFeedback: vi.fn(),
-    emitModelChanged: vi.fn(),
-    emitConsoleLog: vi.fn(),
-}));
-vi.mock('../utils/events.js', () => ({
-    coreEvents: mockCoreEvents,
-}));
+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 {
@@ -48,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
@@ -55,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(),
 }));
@@ -81,16 +80,13 @@ vi.mock('../tools/memoryTool', () => ({
     CELL_DIR: '.cell-cli',
 }));
 vi.mock('../core/contentGenerator.js');
-vi.mock('../core/client.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        GeminiClient: vi.fn().mockImplementation(() => ({
-            initialize: vi.fn().mockResolvedValue(undefined),
-            stripThoughtsFromHistory: vi.fn(),
-        })),
-    };
-});
+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) => {
     const actual = await importOriginal();
     return {
@@ -130,18 +126,36 @@ 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 mockSetGlobalProxy = vi.hoisted(() => vi.fn());
+const mockCoreEvents = vi.hoisted(() => ({
+    emitFeedback: vi.fn(),
+    emitModelChanged: vi.fn(),
+    emitConsoleLog: vi.fn(),
+    on: vi.fn(),
+}));
+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');
 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(),
@@ -149,7 +163,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',
@@ -177,7 +191,10 @@ describe('Server Config (config.ts)', () => {
     beforeEach(() => {
         // Reset mocks if necessary
         vi.clearAllMocks();
-        vi.spyOn(ClearcutLogger.prototype, 'logStartSessionEvent').mockImplementation(() => undefined);
+        vi.mocked(getExperiments).mockResolvedValue({
+            experimentIds: [],
+            flags: {},
+        });
     });
     describe('initialize', () => {
         it('should throw an error if checkpointing is enabled and GitService fails', async () => {
@@ -288,20 +305,23 @@ 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, vi.fn());
+            await config.refreshAuth(authType);
             expect(createContentGeneratorConfig).toHaveBeenCalledWith(expect.any(Config), authType, {
                 clientId: undefined,
                 deviceEndpoint: undefined,
                 tokenEndpoint: undefined,
-            }, expect.any(Function));
+            }, undefined);
             // 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, _keycloakOptions, _displayMessage) => ({ 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);
@@ -641,6 +661,36 @@ describe('Server Config (config.ts)', () => {
             expect(config.getUseRipgrep()).toBe(true);
         });
     });
+    describe('UseWriteTodos Configuration', () => {
+        it('should default useWriteTodos to true when not provided', () => {
+            const config = new Config(baseParams);
+            expect(config.getUseWriteTodos()).toBe(true);
+        });
+        it('should set useWriteTodos to false when provided as false', () => {
+            const params = {
+                ...baseParams,
+                useWriteTodos: false,
+            };
+            const config = new Config(params);
+            expect(config.getUseWriteTodos()).toBe(false);
+        });
+        it('should disable useWriteTodos for preview models', () => {
+            const params = {
+                ...baseParams,
+                model: 'gemini-3-pro-preview',
+            };
+            const config = new Config(params);
+            expect(config.getUseWriteTodos()).toBe(false);
+        });
+        it('should NOT disable useWriteTodos for non-preview models', () => {
+            const params = {
+                ...baseParams,
+                model: 'gemini-2.5-pro',
+            };
+            const config = new Config(params);
+            expect(config.getUseWriteTodos()).toBe(true);
+        });
+    });
     describe('Shell Tool Inactivity Timeout', () => {
         it('should default to 300000ms (300 seconds) when not provided', () => {
             const config = new Config(baseParams);
@@ -707,24 +757,30 @@ 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 () => {
             const params = {
                 ...baseParams,
                 codebaseInvestigatorSettings: { enabled: false },
+                cliHelpAgentSettings: { 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(() => {
@@ -982,6 +1038,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': {
@@ -1108,26 +1184,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',
@@ -1136,12 +1212,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();
         });
     });
 });
@@ -1238,4 +1341,267 @@ 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).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([]);
+        });
+        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);
+        });
+    });
+});
 //# sourceMappingURL=config.test.js.map