@didim365/agent-cli-core 0.1.1 → 0.1.2

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

@@ -1,1811 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from './config.js';
-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 * 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 { GeminiClient } from '../core/client.js';
-import { GitService } from '../services/gitService.js';
-import { ShellTool } from '../tools/shell.js';
-import { ReadFileTool } from '../tools/read-file.js';
-import { GrepTool } from '../tools/grep.js';
-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 {
-        ...actual,
-        existsSync: vi.fn().mockReturnValue(true),
-        statSync: vi.fn().mockReturnValue({
-            isDirectory: vi.fn().mockReturnValue(true),
-        }),
-        realpathSync: vi.fn((path) => path),
-    };
-});
-// Mock dependencies that might be called during Config construction or createServerConfig
-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
-    ToolRegistryMock.prototype.getTool = vi.fn();
-    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(),
-}));
-// Mock individual tools if their constructors are complex or have side effects
-vi.mock('../tools/ls');
-vi.mock('../tools/read-file');
-vi.mock('../tools/grep.js');
-vi.mock('../tools/ripGrep.js', () => ({
-    canUseRipgrep: vi.fn(),
-    RipGrepTool: class MockRipGrepTool {
-    },
-}));
-vi.mock('../tools/glob');
-vi.mock('../tools/edit');
-vi.mock('../tools/shell');
-vi.mock('../tools/write-file');
-vi.mock('../tools/web-fetch');
-vi.mock('../tools/read-many-files');
-vi.mock('../tools/memoryTool', () => ({
-    MemoryTool: vi.fn(),
-    setGeminiMdFilename: vi.fn(),
-    getCurrentGeminiMdFilename: vi.fn(() => 'GEMINI.md'), // Mock the original filename
-    DEFAULT_CONTEXT_FILENAME: 'GEMINI.md',
-    GEMINI_DIR: '.gemini',
-}));
-vi.mock('../core/contentGenerator.js');
-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 {
-        ...actual,
-        initializeTelemetry: vi.fn(),
-        uiTelemetryService: {
-            getLastPromptTokenCount: vi.fn(),
-        },
-    };
-});
-vi.mock('../telemetry/loggers.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        logRipgrepFallback: vi.fn(),
-    };
-});
-vi.mock('../services/gitService.js', () => {
-    const GitServiceMock = vi.fn();
-    GitServiceMock.prototype.initialize = vi.fn();
-    return { GitService: GitServiceMock };
-});
-vi.mock('../ide/ide-client.js', () => ({
-    IdeClient: {
-        getInstance: vi.fn().mockResolvedValue({
-            getConnectionStatus: vi.fn(),
-            initialize: vi.fn(),
-            shutdown: vi.fn(),
-        }),
-    },
-}));
-vi.mock('../agents/registry.js', () => {
-    const AgentRegistryMock = vi.fn();
-    AgentRegistryMock.prototype.initialize = vi.fn();
-    AgentRegistryMock.prototype.getAllDefinitions = vi.fn(() => []);
-    AgentRegistryMock.prototype.getDefinition = vi.fn();
-    return { AgentRegistry: AgentRegistryMock };
-});
-vi.mock('../agents/subagent-tool.js', () => ({
-    SubagentTool: vi.fn(),
-}));
-vi.mock('../resources/resource-registry.js', () => ({
-    ResourceRegistry: vi.fn(),
-}));
-const mockCoreEvents = vi.hoisted(() => ({
-    emitFeedback: vi.fn(),
-    emitModelChanged: vi.fn(),
-    emitConsoleLog: vi.fn(),
-    on: vi.fn(),
-}));
-const mockSetGlobalProxy = vi.hoisted(() => 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(),
-}));
-vi.mock('../code_assist/codeAssist.js');
-vi.mock('../code_assist/experiments/experiments.js');
-describe('Server Config (config.ts)', () => {
-    const MODEL = DEFAULT_GEMINI_MODEL;
-    const SANDBOX = {
-        command: 'docker',
-        image: 'gemini-cli-sandbox',
-    };
-    const TARGET_DIR = '/path/to/target';
-    const DEBUG_MODE = false;
-    const QUESTION = 'test question';
-    const USER_MEMORY = 'Test User Memory';
-    const TELEMETRY_SETTINGS = { enabled: false };
-    const EMBEDDING_MODEL = 'gemini-embedding';
-    const SESSION_ID = 'test-session-id';
-    const baseParams = {
-        cwd: '/tmp',
-        embeddingModel: EMBEDDING_MODEL,
-        sandbox: SANDBOX,
-        targetDir: TARGET_DIR,
-        debugMode: DEBUG_MODE,
-        question: QUESTION,
-        userMemory: USER_MEMORY,
-        telemetry: TELEMETRY_SETTINGS,
-        sessionId: SESSION_ID,
-        model: MODEL,
-        usageStatisticsEnabled: false,
-    };
-    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);
-            const config = new Config({
-                ...baseParams,
-                checkpointing: true,
-            });
-            await expect(config.initialize()).rejects.toThrow(gitError);
-        });
-        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);
-            const config = new Config({
-                ...baseParams,
-                checkpointing: false,
-            });
-            await expect(config.initialize()).resolves.toBeUndefined();
-        });
-        it('should throw an error if initialized more than once', async () => {
-            const config = new Config({
-                ...baseParams,
-                checkpointing: false,
-            });
-            await expect(config.initialize()).resolves.toBeUndefined();
-            await expect(config.initialize()).rejects.toThrow('Config was already initialized');
-        });
-        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;
-            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;
-            McpClientManager.mockImplementation(() => ({
-                startConfiguredMcpServers: vi.fn().mockImplementation(async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 50));
-                    mcpStarted = true;
-                }),
-                getMcpInstructions: vi.fn(),
-            }));
-            await config.initialize();
-            // Should return immediately, before MCP finishes
-            expect(mcpStarted).toBe(false);
-            // Wait for it to eventually finish to avoid open handles
-            await new Promise((resolve) => setTimeout(resolve, 60));
-            expect(mcpStarted).toBe(true);
-        });
-        describe('getCompressionThreshold', () => {
-            it('should return the local compression threshold if it is set', async () => {
-                const config = new Config({
-                    ...baseParams,
-                    compressionThreshold: 0.5,
-                });
-                expect(await config.getCompressionThreshold()).toBe(0.5);
-            });
-            it('should return the remote experiment threshold if it is a positive number', async () => {
-                const config = new Config({
-                    ...baseParams,
-                    experiments: {
-                        flags: {
-                            [ExperimentFlags.CONTEXT_COMPRESSION_THRESHOLD]: {
-                                floatValue: 0.8,
-                            },
-                        },
-                    },
-                });
-                expect(await config.getCompressionThreshold()).toBe(0.8);
-            });
-            it('should return undefined if the remote experiment threshold is 0', async () => {
-                const config = new Config({
-                    ...baseParams,
-                    experiments: {
-                        flags: {
-                            [ExperimentFlags.CONTEXT_COMPRESSION_THRESHOLD]: {
-                                floatValue: 0.0,
-                            },
-                        },
-                    },
-                });
-                expect(await config.getCompressionThreshold()).toBeUndefined();
-            });
-            it('should return undefined if there are no experiments', async () => {
-                const config = new Config(baseParams);
-                expect(await config.getCompressionThreshold()).toBeUndefined();
-            });
-        });
-        describe('getUserCaching', () => {
-            it('should return the remote experiment flag when available', async () => {
-                const config = new Config({
-                    ...baseParams,
-                    experiments: {
-                        flags: {
-                            [ExperimentFlags.USER_CACHING]: {
-                                boolValue: true,
-                            },
-                        },
-                        experimentIds: [],
-                    },
-                });
-                expect(await config.getUserCaching()).toBe(true);
-            });
-            it('should return false when the remote flag is false', async () => {
-                const config = new Config({
-                    ...baseParams,
-                    experiments: {
-                        flags: {
-                            [ExperimentFlags.USER_CACHING]: {
-                                boolValue: false,
-                            },
-                        },
-                        experimentIds: [],
-                    },
-                });
-                expect(await config.getUserCaching()).toBe(false);
-            });
-            it('should return undefined if there are no experiments', async () => {
-                const config = new Config(baseParams);
-                expect(await config.getUserCaching()).toBeUndefined();
-            });
-        });
-    });
-    describe('refreshAuth', () => {
-        it('should refresh auth and update config', async () => {
-            const config = new Config(baseParams);
-            const authType = AuthType.USE_GEMINI;
-            const mockContentConfig = {
-                apiKey: 'test-key',
-            };
-            vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
-            await config.refreshAuth(authType);
-            expect(createContentGeneratorConfig).toHaveBeenCalledWith(config, authType);
-            // Verify that contentGeneratorConfig is updated
-            expect(config.getContentGeneratorConfig()).toEqual(mockContentConfig);
-            expect(GeminiClient).toHaveBeenCalledWith(config);
-        });
-        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);
-            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 }));
-            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 }));
-            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);
-        // Verify other getters if needed
-        expect(config.getTargetDir()).toBe(path.resolve(TARGET_DIR)); // Check resolved path
-    });
-    it('Config constructor should default userMemory to empty string if not provided', () => {
-        const paramsWithoutMemory = { ...baseParams };
-        delete paramsWithoutMemory.userMemory;
-        const config = new Config(paramsWithoutMemory);
-        expect(config.getUserMemory()).toBe('');
-    });
-    it('Config constructor should call setGeminiMdFilename with contextFileName if provided', () => {
-        const contextFileName = 'CUSTOM_AGENTS.md';
-        const paramsWithContextFile = {
-            ...baseParams,
-            contextFileName,
-        };
-        new Config(paramsWithContextFile);
-        expect(mockSetGeminiMdFilename).toHaveBeenCalledWith(contextFileName);
-    });
-    it('Config constructor should not call setGeminiMdFilename if contextFileName is not provided', () => {
-        new Config(baseParams); // baseParams does not have contextFileName
-        expect(mockSetGeminiMdFilename).not.toHaveBeenCalled();
-    });
-    it('should set default file filtering settings when not provided', () => {
-        const config = new Config(baseParams);
-        expect(config.getFileFilteringRespectGitIgnore()).toBe(DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore);
-    });
-    it('should set custom file filtering settings when provided', () => {
-        const paramsWithFileFiltering = {
-            ...baseParams,
-            fileFiltering: {
-                respectGitIgnore: false,
-            },
-        };
-        const config = new Config(paramsWithFileFiltering);
-        expect(config.getFileFilteringRespectGitIgnore()).toBe(false);
-    });
-    it('should initialize WorkspaceContext with includeDirectories', () => {
-        const includeDirectories = ['dir1', 'dir2'];
-        const paramsWithIncludeDirs = {
-            ...baseParams,
-            includeDirectories,
-        };
-        const config = new Config(paramsWithIncludeDirs);
-        const workspaceContext = config.getWorkspaceContext();
-        const directories = workspaceContext.getDirectories();
-        // Should include only the target directory initially
-        expect(directories).toHaveLength(1);
-        expect(directories).toContain(path.resolve(baseParams.targetDir));
-        // The other directories should be in the pending list
-        expect(config.getPendingIncludeDirectories()).toEqual(includeDirectories);
-    });
-    it('Config constructor should set telemetry to true when provided as true', () => {
-        const paramsWithTelemetry = {
-            ...baseParams,
-            telemetry: { enabled: true },
-        };
-        const config = new Config(paramsWithTelemetry);
-        expect(config.getTelemetryEnabled()).toBe(true);
-    });
-    it('Config constructor should set telemetry to false when provided as false', () => {
-        const paramsWithTelemetry = {
-            ...baseParams,
-            telemetry: { enabled: false },
-        };
-        const config = new Config(paramsWithTelemetry);
-        expect(config.getTelemetryEnabled()).toBe(false);
-    });
-    it('Config constructor should default telemetry to default value if not provided', () => {
-        const paramsWithoutTelemetry = { ...baseParams };
-        delete paramsWithoutTelemetry.telemetry;
-        const config = new Config(paramsWithoutTelemetry);
-        expect(config.getTelemetryEnabled()).toBe(TELEMETRY_SETTINGS.enabled);
-    });
-    it('Config constructor should set telemetry useCollector to true when provided', () => {
-        const paramsWithTelemetry = {
-            ...baseParams,
-            telemetry: { enabled: true, useCollector: true },
-        };
-        const config = new Config(paramsWithTelemetry);
-        expect(config.getTelemetryUseCollector()).toBe(true);
-    });
-    it('Config constructor should set telemetry useCollector to false when provided', () => {
-        const paramsWithTelemetry = {
-            ...baseParams,
-            telemetry: { enabled: true, useCollector: false },
-        };
-        const config = new Config(paramsWithTelemetry);
-        expect(config.getTelemetryUseCollector()).toBe(false);
-    });
-    it('Config constructor should default telemetry useCollector to false if not provided', () => {
-        const paramsWithTelemetry = {
-            ...baseParams,
-            telemetry: { enabled: true },
-        };
-        const config = new Config(paramsWithTelemetry);
-        expect(config.getTelemetryUseCollector()).toBe(false);
-    });
-    it('should have a getFileService method that returns FileDiscoveryService', () => {
-        const config = new Config(baseParams);
-        const fileService = config.getFileService();
-        expect(fileService).toBeDefined();
-    });
-    describe('Usage Statistics', () => {
-        it('defaults usage statistics to enabled if not specified', () => {
-            const config = new Config({
-                ...baseParams,
-                usageStatisticsEnabled: undefined,
-            });
-            expect(config.getUsageStatisticsEnabled()).toBe(true);
-        });
-        it.each([{ enabled: true }, { enabled: false }])('sets usage statistics based on the provided value (enabled: $enabled)', ({ enabled }) => {
-            const config = new Config({
-                ...baseParams,
-                usageStatisticsEnabled: enabled,
-            });
-            expect(config.getUsageStatisticsEnabled()).toBe(enabled);
-        });
-    });
-    describe('Telemetry Settings', () => {
-        it('should return default telemetry target if not provided', () => {
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryTarget()).toBe(DEFAULT_TELEMETRY_TARGET);
-        });
-        it('should return provided OTLP endpoint', () => {
-            const endpoint = 'http://custom.otel.collector:4317';
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true, otlpEndpoint: endpoint },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryOtlpEndpoint()).toBe(endpoint);
-        });
-        it('should return default OTLP endpoint if not provided', () => {
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryOtlpEndpoint()).toBe(DEFAULT_OTLP_ENDPOINT);
-        });
-        it('should return provided logPrompts setting', () => {
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true, logPrompts: false },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
-        });
-        it('should return default logPrompts setting (true) if not provided', () => {
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
-        });
-        it('should return default logPrompts setting (true) if telemetry object is not provided', () => {
-            const paramsWithoutTelemetry = { ...baseParams };
-            delete paramsWithoutTelemetry.telemetry;
-            const config = new Config(paramsWithoutTelemetry);
-            expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
-        });
-        it('should return default telemetry target if telemetry object is not provided', () => {
-            const paramsWithoutTelemetry = { ...baseParams };
-            delete paramsWithoutTelemetry.telemetry;
-            const config = new Config(paramsWithoutTelemetry);
-            expect(config.getTelemetryTarget()).toBe(DEFAULT_TELEMETRY_TARGET);
-        });
-        it('should return default OTLP endpoint if telemetry object is not provided', () => {
-            const paramsWithoutTelemetry = { ...baseParams };
-            delete paramsWithoutTelemetry.telemetry;
-            const config = new Config(paramsWithoutTelemetry);
-            expect(config.getTelemetryOtlpEndpoint()).toBe(DEFAULT_OTLP_ENDPOINT);
-        });
-        it('should return provided OTLP protocol', () => {
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true, otlpProtocol: 'http' },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryOtlpProtocol()).toBe('http');
-        });
-        it('should return default OTLP protocol if not provided', () => {
-            const params = {
-                ...baseParams,
-                telemetry: { enabled: true },
-            };
-            const config = new Config(params);
-            expect(config.getTelemetryOtlpProtocol()).toBe('grpc');
-        });
-        it('should return default OTLP protocol if telemetry object is not provided', () => {
-            const paramsWithoutTelemetry = { ...baseParams };
-            delete paramsWithoutTelemetry.telemetry;
-            const config = new Config(paramsWithoutTelemetry);
-            expect(config.getTelemetryOtlpProtocol()).toBe('grpc');
-        });
-    });
-    describe('UseRipgrep Configuration', () => {
-        it('should default useRipgrep to true when not provided', () => {
-            const config = new Config(baseParams);
-            expect(config.getUseRipgrep()).toBe(true);
-        });
-        it('should set useRipgrep to false when provided as false', () => {
-            const paramsWithRipgrep = {
-                ...baseParams,
-                useRipgrep: false,
-            };
-            const config = new Config(paramsWithRipgrep);
-            expect(config.getUseRipgrep()).toBe(false);
-        });
-        it('should set useRipgrep to true when explicitly provided as true', () => {
-            const paramsWithRipgrep = {
-                ...baseParams,
-                useRipgrep: true,
-            };
-            const config = new Config(paramsWithRipgrep);
-            expect(config.getUseRipgrep()).toBe(true);
-        });
-        it('should default useRipgrep to true when undefined', () => {
-            const paramsWithUndefinedRipgrep = {
-                ...baseParams,
-                useRipgrep: undefined,
-            };
-            const config = new Config(paramsWithUndefinedRipgrep);
-            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('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);
-            expect(config.getShellToolInactivityTimeout()).toBe(300000);
-        });
-        it('should convert provided seconds to milliseconds', () => {
-            const params = {
-                ...baseParams,
-                shellToolInactivityTimeout: 10, // 10 seconds
-            };
-            const config = new Config(params);
-            expect(config.getShellToolInactivityTimeout()).toBe(10000);
-        });
-    });
-    describe('ContinueOnFailedApiCall Configuration', () => {
-        it('should default continueOnFailedApiCall to false when not provided', () => {
-            const config = new Config(baseParams);
-            expect(config.getContinueOnFailedApiCall()).toBe(true);
-        });
-        it('should set continueOnFailedApiCall to true when provided as true', () => {
-            const paramsWithContinueOnFailedApiCall = {
-                ...baseParams,
-                continueOnFailedApiCall: true,
-            };
-            const config = new Config(paramsWithContinueOnFailedApiCall);
-            expect(config.getContinueOnFailedApiCall()).toBe(true);
-        });
-        it('should set continueOnFailedApiCall to false when explicitly provided as false', () => {
-            const paramsWithContinueOnFailedApiCall = {
-                ...baseParams,
-                continueOnFailedApiCall: false,
-            };
-            const config = new Config(paramsWithContinueOnFailedApiCall);
-            expect(config.getContinueOnFailedApiCall()).toBe(false);
-        });
-    });
-    describe('createToolRegistry', () => {
-        it('should register a tool if coreTools contains an argument-specific pattern', async () => {
-            const params = {
-                ...baseParams,
-                coreTools: ['ShellTool(git status)'],
-            };
-            const config = new Config(params);
-            await config.initialize();
-            // The ToolRegistry class is mocked, so we can inspect its prototype's methods.
-            const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
-            // Check that registerTool was called for ShellTool
-            const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
-            expect(wasShellToolRegistered).toBe(true);
-            // Check that registerTool was NOT called for ReadFileTool
-            const wasReadFileToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ReadFileTool));
-            expect(wasReadFileToolRegistered).toBe(false);
-        });
-        it('should register subagents as tools when agents.overrides.codebase_investigator.enabled is true', async () => {
-            const params = {
-                ...baseParams,
-                agents: {
-                    overrides: {
-                        codebase_investigator: { enabled: true },
-                    },
-                },
-            };
-            const config = new Config(params);
-            const mockAgentDefinition = {
-                name: 'codebase-investigator',
-                description: 'Agent 1',
-                instructions: 'Inst 1',
-            };
-            const AgentRegistryMock = (await vi.importMock('../agents/registry.js')).AgentRegistry;
-            AgentRegistryMock.prototype.getDefinition.mockReturnValue(mockAgentDefinition);
-            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(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 SubAgentToolMock);
-            expect(registeredWrappers).toHaveLength(1);
-        });
-        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(() => {
-                Object.defineProperty(vi.mocked(ShellTool).prototype.constructor, 'name', {
-                    value: '_ShellTool',
-                    configurable: true,
-                });
-            });
-            afterEach(() => {
-                Object.defineProperty(vi.mocked(ShellTool).prototype.constructor, 'name', {
-                    value: 'ShellTool',
-                });
-            });
-            it('should register a tool if coreTools contains the non-minified class name', async () => {
-                const params = {
-                    ...baseParams,
-                    coreTools: ['ShellTool'],
-                };
-                const config = new Config(params);
-                await config.initialize();
-                const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
-                const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
-                expect(wasShellToolRegistered).toBe(true);
-            });
-            it('should register a tool if coreTools contains an argument-specific pattern with the non-minified class name', async () => {
-                const params = {
-                    ...baseParams,
-                    coreTools: ['ShellTool(git status)'],
-                };
-                const config = new Config(params);
-                await config.initialize();
-                const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
-                const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
-                expect(wasShellToolRegistered).toBe(true);
-            });
-        });
-    });
-    describe('getTruncateToolOutputThreshold', () => {
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should return the calculated threshold when it is smaller than the default', () => {
-            const config = new Config(baseParams);
-            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);
-        });
-        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);
-        });
-        it('should use a custom truncateToolOutputThreshold if provided', () => {
-            const customParams = {
-                ...baseParams,
-                truncateToolOutputThreshold: 50000,
-            };
-            const config = new Config(customParams);
-            vi.mocked(tokenLimit).mockReturnValue(8000);
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(2000);
-            // 4 * (8000 - 2000) = 4 * 6000 = 24000
-            // custom threshold is 50000
-            expect(config.getTruncateToolOutputThreshold()).toBe(24000);
-            vi.mocked(tokenLimit).mockReturnValue(32000);
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(1000);
-            // 4 * (32000 - 1000) = 124000
-            // custom threshold is 50000
-            expect(config.getTruncateToolOutputThreshold()).toBe(50000);
-        });
-    });
-    describe('Proxy Configuration Error Handling', () => {
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should call setGlobalProxy when proxy is configured', () => {
-            const paramsWithProxy = {
-                ...baseParams,
-                proxy: 'http://proxy.example.com:8080',
-            };
-            new Config(paramsWithProxy);
-            expect(mockSetGlobalProxy).toHaveBeenCalledWith('http://proxy.example.com:8080');
-        });
-        it('should not call setGlobalProxy when proxy is not configured', () => {
-            new Config(baseParams);
-            expect(mockSetGlobalProxy).not.toHaveBeenCalled();
-        });
-        it('should emit error feedback when setGlobalProxy throws an error', () => {
-            const proxyError = new Error('Invalid proxy URL');
-            mockSetGlobalProxy.mockImplementation(() => {
-                throw proxyError;
-            });
-            const paramsWithProxy = {
-                ...baseParams,
-                proxy: 'invalid-proxy',
-            };
-            new Config(paramsWithProxy);
-            expect(mockCoreEvents.emitFeedback).toHaveBeenCalledWith('error', 'Invalid proxy configuration detected. Check debug drawer for more details (F12)', proxyError);
-        });
-        it('should not emit error feedback when setGlobalProxy succeeds', () => {
-            mockSetGlobalProxy.mockImplementation(() => {
-                // Success - no error thrown
-            });
-            const paramsWithProxy = {
-                ...baseParams,
-                proxy: 'http://proxy.example.com:8080',
-            };
-            new Config(paramsWithProxy);
-            expect(mockCoreEvents.emitFeedback).not.toHaveBeenCalled();
-        });
-    });
-});
-describe('setApprovalMode with folder trust', () => {
-    const baseParams = {
-        sessionId: 'test',
-        targetDir: '.',
-        debugMode: false,
-        model: 'test-model',
-        cwd: '.',
-    };
-    it('should throw an error when setting YOLO mode in an untrusted folder', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
-        expect(() => config.setApprovalMode(ApprovalMode.YOLO)).toThrow('Cannot enable privileged approval modes in an untrusted folder.');
-    });
-    it('should throw an error when setting AUTO_EDIT mode in an untrusted folder', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
-        expect(() => config.setApprovalMode(ApprovalMode.AUTO_EDIT)).toThrow('Cannot enable privileged approval modes in an untrusted folder.');
-    });
-    it('should NOT throw an error when setting DEFAULT mode in an untrusted folder', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
-        expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
-    });
-    it('should NOT throw an error when setting any mode in a trusted folder', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
-        expect(() => config.setApprovalMode(ApprovalMode.YOLO)).not.toThrow();
-        expect(() => config.setApprovalMode(ApprovalMode.AUTO_EDIT)).not.toThrow();
-        expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
-    });
-    it('should NOT throw an error when setting any mode if trustedFolder is undefined', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true); // isTrustedFolder defaults to true
-        expect(() => config.setApprovalMode(ApprovalMode.YOLO)).not.toThrow();
-        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);
-        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);
-        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);
-            const config = new Config({ ...baseParams, useRipgrep: true });
-            await config.initialize();
-            const calls = 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);
-            expect(wasGrepRegistered).toBe(false);
-            expect(logRipgrepFallback).not.toHaveBeenCalled();
-        });
-        it('should register GrepTool as a fallback when useRipgrep is true but it is not available', async () => {
-            canUseRipgrep.mockResolvedValue(false);
-            const config = new Config({ ...baseParams, useRipgrep: true });
-            await config.initialize();
-            const calls = 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];
-            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);
-            const config = new Config({ ...baseParams, useRipgrep: true });
-            await config.initialize();
-            const calls = 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];
-            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 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(canUseRipgrep).not.toHaveBeenCalled();
-            expect(logRipgrepFallback).not.toHaveBeenCalled();
-        });
-    });
-});
-describe('isYoloModeDisabled', () => {
-    const baseParams = {
-        sessionId: 'test',
-        targetDir: '.',
-        debugMode: false,
-        model: 'test-model',
-        cwd: '.',
-    };
-    it('should return false when yolo mode is not disabled and folder is trusted', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
-        expect(config.isYoloModeDisabled()).toBe(false);
-    });
-    it('should return true when yolo mode is disabled by parameter', () => {
-        const config = new Config({ ...baseParams, disableYoloMode: true });
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
-        expect(config.isYoloModeDisabled()).toBe(true);
-    });
-    it('should return true when folder is untrusted', () => {
-        const config = new Config(baseParams);
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
-        expect(config.isYoloModeDisabled()).toBe(true);
-    });
-    it('should return true when yolo is disabled and folder is untrusted', () => {
-        const config = new Config({ ...baseParams, disableYoloMode: true });
-        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
-        expect(config.isYoloModeDisabled()).toBe(true);
-    });
-});
-describe('BaseLlmClient Lifecycle', () => {
-    const MODEL = 'gemini-pro';
-    const SANDBOX = {
-        command: 'docker',
-        image: 'gemini-cli-sandbox',
-    };
-    const TARGET_DIR = '/path/to/target';
-    const DEBUG_MODE = false;
-    const QUESTION = 'test question';
-    const USER_MEMORY = 'Test User Memory';
-    const TELEMETRY_SETTINGS = { enabled: false };
-    const EMBEDDING_MODEL = 'gemini-embedding';
-    const SESSION_ID = 'test-session-id';
-    const baseParams = {
-        cwd: '/tmp',
-        embeddingModel: EMBEDDING_MODEL,
-        sandbox: SANDBOX,
-        targetDir: TARGET_DIR,
-        debugMode: DEBUG_MODE,
-        question: QUESTION,
-        userMemory: USER_MEMORY,
-        telemetry: TELEMETRY_SETTINGS,
-        sessionId: SESSION_ID,
-        model: MODEL,
-        usageStatisticsEnabled: false,
-    };
-    it('should throw an error if getBaseLlmClient is called before refreshAuth', () => {
-        const config = new Config(baseParams);
-        expect(() => config.getBaseLlmClient()).toThrow('BaseLlmClient not initialized. Ensure authentication has occurred and ContentGenerator is ready.');
-    });
-    it('should successfully initialize BaseLlmClient after refreshAuth is called', async () => {
-        const config = new Config(baseParams);
-        const authType = AuthType.USE_GEMINI;
-        const mockContentConfig = { model: 'gemini-flash', apiKey: 'test-key' };
-        vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
-        await config.refreshAuth(authType);
-        // Should not throw
-        const llmService = config.getBaseLlmClient();
-        expect(llmService).toBeDefined();
-        expect(BaseLlmClient).toHaveBeenCalledWith(config.getContentGenerator(), config);
-    });
-});
-describe('Generation Config Merging (HACK)', () => {
-    const MODEL = 'gemini-pro';
-    const SANDBOX = {
-        command: 'docker',
-        image: 'gemini-cli-sandbox',
-    };
-    const TARGET_DIR = '/path/to/target';
-    const DEBUG_MODE = false;
-    const QUESTION = 'test question';
-    const USER_MEMORY = 'Test User Memory';
-    const TELEMETRY_SETTINGS = { enabled: false };
-    const EMBEDDING_MODEL = 'gemini-embedding';
-    const SESSION_ID = 'test-session-id';
-    const baseParams = {
-        cwd: '/tmp',
-        embeddingModel: EMBEDDING_MODEL,
-        sandbox: SANDBOX,
-        targetDir: TARGET_DIR,
-        debugMode: DEBUG_MODE,
-        question: QUESTION,
-        userMemory: USER_MEMORY,
-        telemetry: TELEMETRY_SETTINGS,
-        sessionId: SESSION_ID,
-        model: MODEL,
-        usageStatisticsEnabled: false,
-    };
-    it('should merge default aliases when user provides only overrides', () => {
-        const userOverrides = [
-            {
-                match: { model: 'test-model' },
-                modelConfig: { generateContentConfig: { temperature: 0.1 } },
-            },
-        ];
-        const params = {
-            ...baseParams,
-            modelConfigServiceConfig: {
-                overrides: userOverrides,
-            },
-        };
-        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);
-        // 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': {
-                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 used, not the defaults
-        expect(serviceConfig.aliases).toEqual(userAliases);
-    });
-    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);
-    });
-});
-describe('Config getHooks', () => {
-    const baseParams = {
-        cwd: '/tmp',
-        targetDir: '/path/to/target',
-        debugMode: false,
-        sessionId: 'test-session-id',
-        model: 'gemini-pro',
-        usageStatisticsEnabled: false,
-    };
-    it('should return undefined when no hooks are provided', () => {
-        const config = new Config(baseParams);
-        expect(config.getHooks()).toBeUndefined();
-    });
-    it('should return empty object when empty hooks are provided', () => {
-        const configWithEmptyHooks = new Config({
-            ...baseParams,
-            hooks: {},
-        });
-        expect(configWithEmptyHooks.getHooks()).toEqual({});
-    });
-    it('should return the hooks configuration when provided', () => {
-        const mockHooks = {
-            BeforeTool: [
-                {
-                    hooks: [{ type: HookType.Command, command: 'echo 1' }],
-                },
-            ],
-        };
-        const config = new Config({ ...baseParams, hooks: mockHooks });
-        const retrievedHooks = config.getHooks();
-        expect(retrievedHooks).toEqual(mockHooks);
-    });
-    it('should return hooks with all supported event types', () => {
-        const allEventHooks = {
-            [HookEventName.BeforeAgent]: [
-                { hooks: [{ type: HookType.Command, command: 'test1' }] },
-            ],
-            [HookEventName.AfterAgent]: [
-                { hooks: [{ type: HookType.Command, command: 'test2' }] },
-            ],
-            [HookEventName.BeforeTool]: [
-                { hooks: [{ type: HookType.Command, command: 'test3' }] },
-            ],
-            [HookEventName.AfterTool]: [
-                { hooks: [{ type: HookType.Command, command: 'test4' }] },
-            ],
-            [HookEventName.BeforeModel]: [
-                { hooks: [{ type: HookType.Command, command: 'test5' }] },
-            ],
-            [HookEventName.AfterModel]: [
-                { hooks: [{ type: HookType.Command, command: 'test6' }] },
-            ],
-            [HookEventName.BeforeToolSelection]: [
-                { hooks: [{ type: HookType.Command, command: 'test7' }] },
-            ],
-            [HookEventName.Notification]: [
-                { hooks: [{ type: HookType.Command, command: 'test8' }] },
-            ],
-            [HookEventName.SessionStart]: [
-                { hooks: [{ type: HookType.Command, command: 'test9' }] },
-            ],
-            [HookEventName.SessionEnd]: [
-                { hooks: [{ type: HookType.Command, command: 'test10' }] },
-            ],
-            [HookEventName.PreCompress]: [
-                { hooks: [{ type: HookType.Command, command: 'test11' }] },
-            ],
-        };
-        const config = new Config({
-            ...baseParams,
-            hooks: allEventHooks,
-        });
-        const retrievedHooks = config.getHooks();
-        expect(retrievedHooks).toEqual(allEventHooks);
-        expect(Object.keys(retrievedHooks)).toHaveLength(11); // All hook event types
-    });
-    describe('setModel', () => {
-        it('should allow setting a pro (any) model and reset availability', () => {
-            const config = new Config(baseParams);
-            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(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith(proModel);
-            expect(spy).toHaveBeenCalled();
-        });
-        it('should allow setting auto model from non-auto model and reset availability', () => {
-            const config = new Config(baseParams);
-            const service = config.getModelAvailabilityService();
-            const spy = vi.spyOn(service, 'reset');
-            config.setModel('auto');
-            expect(config.getModel()).toBe('auto');
-            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
-            expect(spy).toHaveBeenCalled();
-        });
-        it('should allow setting auto model from auto model and reset availability', () => {
-            const config = new Config({
-                cwd: '/tmp',
-                targetDir: '/path/to/target',
-                debugMode: false,
-                sessionId: 'test-session-id',
-                model: 'auto',
-                usageStatisticsEnabled: false,
-            });
-            const service = config.getModelAvailabilityService();
-            const spy = vi.spyOn(service, 'reset');
-            config.setModel('auto');
-            expect(config.getModel()).toBe('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();
-        });
-    });
-});
-describe('Config getExperiments', () => {
-    const baseParams = {
-        cwd: '/tmp',
-        targetDir: '/path/to/target',
-        debugMode: false,
-        sessionId: 'test-session-id',
-        model: 'gemini-pro',
-        usageStatisticsEnabled: false,
-    };
-    it('should return undefined when no experiments are provided', () => {
-        const config = new Config(baseParams);
-        expect(config.getExperiments()).toBeUndefined();
-    });
-    it('should return empty object when empty experiments are provided', () => {
-        const configWithEmptyExps = new Config({
-            ...baseParams,
-            experiments: { flags: {}, experimentIds: [] },
-        });
-        expect(configWithEmptyExps.getExperiments()).toEqual({
-            flags: {},
-            experimentIds: [],
-        });
-    });
-    it('should return the experiments configuration when provided', () => {
-        const mockExps = {
-            flags: {
-                testFlag: { boolValue: true },
-            },
-            experimentIds: [],
-        };
-        const config = new Config({
-            ...baseParams,
-            experiments: mockExps,
-        });
-        const retrievedExps = config.getExperiments();
-        expect(retrievedExps).toEqual(mockExps);
-        expect(retrievedExps).toBe(mockExps); // Should return the same reference
-    });
-});
-describe('Config setExperiments logging', () => {
-    const baseParams = {
-        cwd: '/tmp',
-        targetDir: '/path/to/target',
-        debugMode: false,
-        sessionId: 'test-session-id',
-        model: 'gemini-pro',
-        usageStatisticsEnabled: false,
-    };
-    it('logs a sorted, non-truncated summary of experiments when they are set', () => {
-        const config = new Config(baseParams);
-        const debugSpy = vi
-            .spyOn(debugLogger, 'debug')
-            .mockImplementation(() => { });
-        const experiments = {
-            flags: {
-                ZetaFlag: {
-                    boolValue: true,
-                    stringValue: 'zeta',
-                    int32ListValue: { values: [1, 2] },
-                },
-                AlphaFlag: {
-                    boolValue: false,
-                    stringValue: 'alpha',
-                    stringListValue: { values: ['a', 'b', 'c'] },
-                },
-                MiddleFlag: {
-                    // Intentionally sparse to ensure undefined values are omitted
-                    floatValue: 0.42,
-                    int32ListValue: { values: [] },
-                },
-            },
-            experimentIds: [101, 99],
-        };
-        config.setExperiments(experiments);
-        const logCall = debugSpy.mock.calls.find(([message]) => message === 'Experiments loaded');
-        expect(logCall).toBeDefined();
-        const loggedSummary = logCall?.[1];
-        expect(typeof loggedSummary).toBe('string');
-        expect(loggedSummary).toContain('experimentIds');
-        expect(loggedSummary).toContain('101');
-        expect(loggedSummary).toContain('AlphaFlag');
-        expect(loggedSummary).toContain('ZetaFlag');
-        const alphaIndex = loggedSummary.indexOf('AlphaFlag');
-        const zetaIndex = loggedSummary.indexOf('ZetaFlag');
-        expect(alphaIndex).toBeGreaterThan(-1);
-        expect(zetaIndex).toBeGreaterThan(-1);
-        expect(alphaIndex).toBeLessThan(zetaIndex);
-        expect(loggedSummary).toContain('\n');
-        expect(loggedSummary).not.toContain('stringListLength: 0');
-        expect(loggedSummary).not.toContain('int32ListLength: 0');
-        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('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',
-        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('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);
-        });
-    });
-});
-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);
-        });
-    });
-});
-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);
-    });
-});
-//# sourceMappingURL=config.test.js.map