@office-ai/aioncli-core 0.26.0 → 0.30.1

package/dist/src/config/config.js

@@ -1,9 +1,11 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { inspect } from 'node:util';
 import process from 'node:process';
 import { AuthType, createContentGenerator, createContentGeneratorConfig, } from '../core/contentGenerator.js';
@@ -22,20 +24,23 @@ import { WriteFileTool } from '../tools/write-file.js';
 import { WebFetchTool } from '../tools/web-fetch.js';
 import { MemoryTool, setGeminiMdFilename } from '../tools/memoryTool.js';
 import { WebSearchTool } from '../tools/web-search.js';
+import { AskUserTool } from '../tools/ask-user.js';
+import { ExitPlanModeTool } from '../tools/exit-plan-mode.js';
+import { EnterPlanModeTool } from '../tools/enter-plan-mode.js';
 import { GeminiClient } from '../core/client.js';
 import { BaseLlmClient } from '../core/baseLlmClient.js';
 import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
 import { GitService } from '../services/gitService.js';
 import { initializeTelemetry, DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, uiTelemetryService, } from '../telemetry/index.js';
-import { coreEvents } from '../utils/events.js';
+import { coreEvents, CoreEvent } from '../utils/events.js';
 import { tokenLimit } from '../core/tokenLimits.js';
-import { DEFAULT_GEMINI_EMBEDDING_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_MODEL_AUTO, DEFAULT_THINKING_MODE, isPreviewModel, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_MODEL_AUTO, } from './models.js';
+import { DEFAULT_GEMINI_EMBEDDING_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_MODEL_AUTO, isAutoModel, isPreviewModel, PREVIEW_GEMINI_FLASH_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_MODEL_AUTO, resolveModel, } from './models.js';
 import { shouldAttemptBrowserLaunch } from '../utils/browser.js';
 import { ideContextStore } from '../ide/ideContext.js';
 import { WriteTodosTool } from '../tools/write-todos.js';
 import { StandardFileSystemService } from '../services/fileSystemService.js';
 import { logRipgrepFallback, logFlashFallback } from '../telemetry/loggers.js';
-import { RipgrepFallbackEvent, FlashFallbackEvent, } from '../telemetry/types.js';
+import { RipgrepFallbackEvent, FlashFallbackEvent, ApprovalModeSwitchEvent, ApprovalModeDurationEvent, } from '../telemetry/types.js';
 import { ModelAvailabilityService } from '../availability/modelAvailabilityService.js';
 import { ModelRouterService } from '../routing/modelRouterService.js';
 import { OutputFormat } from '../output/types.js';
@@ -47,24 +52,29 @@ import { Storage } from './storage.js';
 import { FileExclusions } from '../utils/ignorePatterns.js';
 import { MessageBus } from '../confirmation-bus/message-bus.js';
 import { PolicyEngine } from '../policy/policy-engine.js';
+import { ApprovalMode } from '../policy/types.js';
 import { HookSystem } from '../hooks/index.js';
 import { getCodeAssistServer } from '../code_assist/codeAssist.js';
 import { AgentRegistry } from '../agents/registry.js';
+import { AcknowledgedAgentsService } from '../agents/acknowledgedAgents.js';
 import { setGlobalProxy } from '../utils/fetch.js';
-import { DelegateToAgentTool } from '../agents/delegate-to-agent-tool.js';
-import { DELEGATE_TO_AGENT_TOOL_NAME } from '../tools/tool-names.js';
+import { SubagentTool } from '../agents/subagent-tool.js';
 import { getExperiments } from '../code_assist/experiments/experiments.js';
 import { ExperimentFlags } from '../code_assist/experiments/flagNames.js';
 import { debugLogger } from '../utils/debugLogger.js';
 import { SkillManager } from '../skills/skillManager.js';
 import { startupProfiler } from '../telemetry/startupProfiler.js';
-import { ApprovalMode } from '../policy/types.js';
+import { logApprovalModeSwitch, logApprovalModeDuration, } from '../telemetry/loggers.js';
+import { fetchAdminControls } from '../code_assist/admin/admin_controls.js';
+import { isSubpath } from '../utils/paths.js';
 import { DEFAULT_FILE_FILTERING_OPTIONS, DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, } from './constants.js';
+import { DEFAULT_TOOL_PROTECTION_THRESHOLD, DEFAULT_MIN_PRUNABLE_TOKENS_THRESHOLD, DEFAULT_PROTECT_LATEST_TURN, } from '../services/toolOutputMaskingService.js';
 import { SimpleExtensionLoader, } from '../utils/extensionLoader.js';
 import { McpClientManager } from '../tools/mcp-client-manager.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { ENTER_PLAN_MODE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, } from '../tools/tool-names.js';
 export { DEFAULT_FILE_FILTERING_OPTIONS, DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, };
-export const DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD = 4_000_000;
-export const DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES = 1000;
+export const DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD = 40_000;
 export class MCPServerConfig {
     command;
     args;
@@ -149,8 +159,10 @@ export class Config {
     promptRegistry;
     resourceRegistry;
     agentRegistry;
+    acknowledgedAgentsService;
     skillManager;
     sessionId;
+    clientVersion;
     fileSystemService;
     contentGeneratorConfig;
     contentGenerator;
@@ -162,13 +174,17 @@ export class Config {
     debugMode;
     question;
     coreTools;
+    /** @deprecated Use Policy Engine instead */
     allowedTools;
+    /** @deprecated Use Policy Engine instead */
     excludeTools;
     toolDiscoveryCommand;
     toolCallCommand;
     mcpServerCommand;
     mcpEnabled;
+    extensionsEnabled;
     mcpServers;
+    mcpEnablementCallbacks;
     userMemory;
     geminiMdFileCount;
     geminiMdFilePaths;
@@ -188,7 +204,7 @@ export class Config {
     cwd;
     bugCommand;
     model;
-    previewFeatures;
+    disableLoopDetection;
     hasAccessToPreviewModel = false;
     noBrowser;
     folderTrust;
@@ -202,26 +218,44 @@ export class Config {
     _enabledExtensions;
     enableExtensionReloading;
     fallbackModelHandler;
+    validationHandler;
     quotaErrorOccurred = false;
+    modelQuotas = new Map();
+    lastRetrievedQuota;
+    lastQuotaFetchTime = 0;
+    lastEmittedQuotaRemaining;
+    lastEmittedQuotaLimit;
+    emitQuotaChangedEvent() {
+        const pooled = this.getPooledQuota();
+        if (this.lastEmittedQuotaRemaining !== pooled.remaining ||
+            this.lastEmittedQuotaLimit !== pooled.limit) {
+            this.lastEmittedQuotaRemaining = pooled.remaining;
+            this.lastEmittedQuotaLimit = pooled.limit;
+            coreEvents.emitQuotaChanged(pooled.remaining, pooled.limit, pooled.resetTime);
+        }
+    }
     summarizeToolOutput;
     experimentalZedIntegration = false;
     loadMemoryFromIncludeDirectories = false;
+    includeDirectoryTree = true;
     importFormat;
     discoveryMaxDirs;
     compressionThreshold;
+    /** Public for testing only */
     interactive;
     ptyInfo;
     trustedFolder;
     useRipgrep;
     enableInteractiveShell;
     skipNextSpeakerCheck;
+    useBackgroundColor;
     shellExecutionConfig;
     extensionManagement = true;
     enablePromptCompletion = false;
     truncateToolOutputThreshold;
-    truncateToolOutputLines;
-    enableToolOutputTruncation;
+    compressionTruncationCounter = 0;
     initialized = false;
+    initPromise;
     storage;
     fileExclusions;
     eventEmitter;
@@ -229,8 +263,6 @@ export class Config {
     messageBus;
     policyEngine;
     outputSettings;
-    codebaseInvestigatorSettings;
-    introspectionAgentSettings;
     continueOnFailedApiCall;
     retryFetchErrors;
     enableShellOutputEfficiency;
@@ -238,8 +270,12 @@ export class Config {
     fakeResponses;
     recordResponses;
     disableYoloMode;
+    rawOutput;
+    acceptRawOutputRisk;
     pendingIncludeDirectories;
     enableHooks;
+    enableHooksUI;
+    toolOutputMasking;
     hooks;
     projectHooks;
     disabledHooks;
@@ -249,14 +285,24 @@ export class Config {
     onModelChange;
     onReload;
     enableAgents;
+    agents;
+    enableEventDrivenScheduler;
     skillsSupport;
     disabledSkills;
+    adminSkillsEnabled;
     experimentalJitContext;
+    disableLLMCorrection;
+    planEnabled;
     contextManager;
     terminalBackground = undefined;
     remoteAdminSettings;
+    latestApiRequest;
+    lastModeSwitchTime = Date.now();
+    approvedPlanPath;
     constructor(params) {
         this.sessionId = params.sessionId;
+        this.clientVersion = params.clientVersion ?? 'unknown';
+        this.approvedPlanPath = undefined;
         this.embeddingModel =
             params.embeddingModel ?? DEFAULT_GEMINI_EMBEDDING_MODEL;
         this.fileSystemService = new StandardFileSystemService();
@@ -274,7 +320,9 @@ export class Config {
         this.toolCallCommand = params.toolCallCommand;
         this.mcpServerCommand = params.mcpServerCommand;
         this.mcpServers = params.mcpServers;
+        this.mcpEnablementCallbacks = params.mcpEnablementCallbacks;
         this.mcpEnabled = params.mcpEnabled ?? true;
+        this.extensionsEnabled = params.extensionsEnabled ?? true;
         this.allowedMcpServers = params.allowedMcpServers ?? [];
         this.blockedMcpServers = params.blockedMcpServers ?? [];
         this.allowedEnvironmentVariables = params.allowedEnvironmentVariables ?? [];
@@ -303,7 +351,14 @@ export class Config {
             respectGeminiIgnore: params.fileFiltering?.respectGeminiIgnore ??
                 DEFAULT_FILE_FILTERING_OPTIONS.respectGeminiIgnore,
             enableRecursiveFileSearch: params.fileFiltering?.enableRecursiveFileSearch ?? true,
-            disableFuzzySearch: params.fileFiltering?.disableFuzzySearch ?? false,
+            enableFuzzySearch: params.fileFiltering?.enableFuzzySearch ?? true,
+            maxFileCount: params.fileFiltering?.maxFileCount ??
+                DEFAULT_FILE_FILTERING_OPTIONS.maxFileCount ??
+                20000,
+            searchTimeout: params.fileFiltering?.searchTimeout ??
+                DEFAULT_FILE_FILTERING_OPTIONS.searchTimeout ??
+                5000,
+            customIgnoreFilePaths: params.fileFiltering?.customIgnoreFilePaths ?? [],
         };
         this.checkpointing = params.checkpointing ?? false;
         this.proxy = params.proxy;
@@ -311,13 +366,27 @@ export class Config {
         this.fileDiscoveryService = params.fileDiscoveryService ?? null;
         this.bugCommand = params.bugCommand;
         this.model = params.model;
+        this.disableLoopDetection = params.disableLoopDetection ?? false;
         this._activeModel = params.model;
         this.enableAgents = params.enableAgents ?? false;
-        this.skillsSupport = params.skillsSupport ?? false;
+        this.agents = params.agents ?? {};
+        this.disableLLMCorrection = params.disableLLMCorrection ?? true;
+        this.planEnabled = params.plan ?? false;
+        this.enableEventDrivenScheduler = params.enableEventDrivenScheduler ?? true;
+        this.skillsSupport = params.skillsSupport ?? true;
         this.disabledSkills = params.disabledSkills ?? [];
+        this.adminSkillsEnabled = params.adminSkillsEnabled ?? true;
         this.modelAvailabilityService = new ModelAvailabilityService();
-        this.previewFeatures = params.previewFeatures ?? undefined;
         this.experimentalJitContext = params.experimentalJitContext ?? false;
+        this.toolOutputMasking = {
+            enabled: params.toolOutputMasking?.enabled ?? true,
+            toolProtectionThreshold: params.toolOutputMasking?.toolProtectionThreshold ??
+                DEFAULT_TOOL_PROTECTION_THRESHOLD,
+            minPrunableTokensThreshold: params.toolOutputMasking?.minPrunableTokensThreshold ??
+                DEFAULT_MIN_PRUNABLE_TOKENS_THRESHOLD,
+            protectLatestTurn: params.toolOutputMasking?.protectLatestTurn ??
+                DEFAULT_PROTECT_LATEST_TURN,
+        };
         this.maxSessionTurns = params.maxSessionTurns ?? -1;
         this.experimentalZedIntegration =
             params.experimentalZedIntegration ?? false;
@@ -331,6 +400,7 @@ export class Config {
         this.summarizeToolOutput = params.summarizeToolOutput;
         this.folderTrust = params.folderTrust ?? false;
         this.ideMode = params.ideMode ?? false;
+        this.includeDirectoryTree = params.includeDirectoryTree ?? true;
         this.loadMemoryFromIncludeDirectories =
             params.loadMemoryFromIncludeDirectories ?? false;
         this.importFormat = params.importFormat ?? 'tree';
@@ -340,6 +410,7 @@ export class Config {
         this.ptyInfo = params.ptyInfo ?? 'child_process';
         this.trustedFolder = params.trustedFolder;
         this.useRipgrep = params.useRipgrep ?? true;
+        this.useBackgroundColor = params.useBackgroundColor ?? true;
         this.enableInteractiveShell = params.enableInteractiveShell ?? false;
         this.skipNextSpeakerCheck = params.skipNextSpeakerCheck ?? true;
         this.shellExecutionConfig = {
@@ -352,29 +423,13 @@ export class Config {
         this.truncateToolOutputThreshold =
             params.truncateToolOutputThreshold ??
                 DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD;
-        this.truncateToolOutputLines =
-            params.truncateToolOutputLines ?? DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES;
-        this.enableToolOutputTruncation = params.enableToolOutputTruncation ?? true;
         // // TODO(joshualitt): Re-evaluate the todo tool for 3 family.
         this.useWriteTodos = isPreviewModel(this.model)
             ? false
             : (params.useWriteTodos ?? true);
-        this.enableHooks = params.enableHooks ?? false;
-        this.disabledHooks =
-            (params.hooks && 'disabled' in params.hooks
-                ? params.hooks.disabled
-                : undefined) ?? [];
-        this.codebaseInvestigatorSettings = {
-            enabled: params.codebaseInvestigatorSettings?.enabled ?? true,
-            maxNumTurns: params.codebaseInvestigatorSettings?.maxNumTurns ?? 10,
-            maxTimeMinutes: params.codebaseInvestigatorSettings?.maxTimeMinutes ?? 3,
-            thinkingBudget: params.codebaseInvestigatorSettings?.thinkingBudget ??
-                DEFAULT_THINKING_MODE,
-            model: params.codebaseInvestigatorSettings?.model,
-        };
-        this.introspectionAgentSettings = {
-            enabled: params.introspectionAgentSettings?.enabled ?? false,
-        };
+        this.enableHooksUI = params.enableHooksUI ?? true;
+        this.enableHooks = params.enableHooks ?? true;
+        this.disabledHooks = params.disabledHooks ?? [];
         this.continueOnFailedApiCall = params.continueOnFailedApiCall ?? true;
         this.enableShellOutputEfficiency =
             params.enableShellOutputEfficiency ?? true;
@@ -382,7 +437,7 @@ export class Config {
             (params.shellToolInactivityTimeout ?? 300) * 1000; // 5 minutes
         this.extensionManagement = params.extensionManagement ?? true;
         this.enableExtensionReloading = params.enableExtensionReloading ?? false;
-        this.storage = new Storage(this.targetDir);
+        this.storage = new Storage(this.targetDir, this.sessionId);
         this.fakeResponses = params.fakeResponses;
         this.recordResponses = params.recordResponses;
         this.enablePromptCompletion = params.enablePromptCompletion ?? false;
@@ -393,14 +448,21 @@ export class Config {
             approvalMode: params.approvalMode ?? params.policyEngineConfig?.approvalMode,
         });
         this.messageBus = new MessageBus(this.policyEngine, this.debugMode);
+        this.acknowledgedAgentsService = new AcknowledgedAgentsService();
         this.skillManager = new SkillManager();
         this.outputSettings = {
             format: params.output?.format ?? OutputFormat.TEXT,
         };
         this.retryFetchErrors = params.retryFetchErrors ?? false;
         this.disableYoloMode = params.disableYoloMode ?? false;
-        this.hooks = params.hooks;
-        this.projectHooks = params.projectHooks;
+        this.rawOutput = params.rawOutput ?? false;
+        this.acceptRawOutputRisk = params.acceptRawOutputRisk ?? false;
+        if (params.hooks) {
+            this.hooks = params.hooks;
+        }
+        if (params.projectHooks) {
+            this.projectHooks = params.projectHooks;
+        }
         this.experiments = params.experiments;
         this.onModelChange = params.onModelChange;
         this.onReload = params.onReload;
@@ -446,14 +508,32 @@ export class Config {
         }
         this.modelConfigService = new ModelConfigService(modelConfigServiceConfig ?? DEFAULT_MODEL_CONFIGS);
     }
+    isInitialized() {
+        return this.initialized;
+    }
     /**
-     * Must only be called once, throws if called again.
+     * Dedups initialization requests using a shared promise that is only resolved
+     * once.
      */
     async initialize() {
-        if (this.initialized) {
-            throw Error('Config was already initialized');
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._initialize();
+        return this.initPromise;
+    }
+    async _initialize() {
+        await this.storage.initialize();
+        // Add pending directories to workspace context
+        for (const dir of this.pendingIncludeDirectories) {
+            this.workspaceContext.addDirectory(dir);
+        }
+        // Add plans directory to workspace context for plan file storage
+        if (this.planEnabled) {
+            const plansDir = this.storage.getProjectTempPlansDir();
+            await fs.promises.mkdir(plansDir, { recursive: true });
+            this.workspaceContext.addDirectory(plansDir);
         }
-        this.initialized = true;
         // Initialize centralized FileDiscoveryService
         const discoverToolsHandle = startupProfiler.start('discover_tools');
         this.getFileService();
@@ -464,22 +544,35 @@ export class Config {
         this.resourceRegistry = new ResourceRegistry();
         this.agentRegistry = new AgentRegistry(this);
         await this.agentRegistry.initialize();
+        coreEvents.on(CoreEvent.AgentsRefreshed, this.onAgentsRefreshed);
         this.toolRegistry = await this.createToolRegistry();
         discoverToolsHandle?.end();
-        this.mcpClientManager = new McpClientManager(this.toolRegistry, this, this.eventEmitter);
-        const initMcpHandle = startupProfiler.start('initialize_mcp_clients');
-        await Promise.all([
-            await this.mcpClientManager.startConfiguredMcpServers(),
-            await this.getExtensionLoader().start(this),
-        ]);
-        initMcpHandle?.end();
-        // Discover skills if enabled
+        this.mcpClientManager = new McpClientManager(this.clientVersion, this.toolRegistry, this, this.eventEmitter);
+        // We do not await this promise so that the CLI can start up even if
+        // MCP servers are slow to connect.
+        const mcpInitialization = Promise.allSettled([
+            this.mcpClientManager.startConfiguredMcpServers(),
+            this.getExtensionLoader().start(this),
+        ]).then((results) => {
+            for (const result of results) {
+                if (result.status === 'rejected') {
+                    debugLogger.error('Error initializing MCP clients:', result.reason);
+                }
+            }
+        });
+        if (!this.interactive || this.experimentalZedIntegration) {
+            await mcpInitialization;
+        }
         if (this.skillsSupport) {
-            await this.getSkillManager().discoverSkills(this.storage, this.getExtensions());
-            this.getSkillManager().setDisabledSkills(this.disabledSkills);
-            // Re-register ActivateSkillTool to update its schema with the discovered enabled skill enums
-            if (this.getSkillManager().getSkills().length > 0) {
-                this.getToolRegistry().registerTool(new ActivateSkillTool(this, this.messageBus));
+            this.getSkillManager().setAdminSettings(this.adminSkillsEnabled);
+            if (this.adminSkillsEnabled) {
+                await this.getSkillManager().discoverSkills(this.storage, this.getExtensions(), this.isTrustedFolder());
+                this.getSkillManager().setDisabledSkills(this.disabledSkills);
+                // Re-register ActivateSkillTool to update its schema with the discovered enabled skill enums
+                if (this.getSkillManager().getSkills().length > 0) {
+                    this.getToolRegistry().unregisterTool(ActivateSkillTool.Name);
+                    this.getToolRegistry().registerTool(new ActivateSkillTool(this, this.messageBus));
+                }
             }
         }
         // Initialize hook system if enabled
@@ -492,6 +585,8 @@ export class Config {
             await this.contextManager.refresh();
         }
         await this.geminiClient.initialize();
+        this.syncPlanModeTools();
+        this.initialized = true;
     }
     getContentGenerator() {
         return this.contentGenerator;
@@ -508,6 +603,11 @@ export class Config {
         }
         // Reset availability status when switching auth (e.g. from limited key to OAuth)
         this.modelAvailabilityService.reset();
+        // Clear stale authType to ensure getGemini31LaunchedSync doesn't return stale results
+        // during the transition.
+        if (this.contentGeneratorConfig) {
+            this.contentGeneratorConfig.authType = undefined;
+        }
         const newContentGeneratorConfig = await createContentGeneratorConfig(this, authMethod);
         this.contentGenerator = await createContentGenerator(newContentGeneratorConfig, this, this.getSessionId());
         // Only assign to instance properties after successful initialization
@@ -515,29 +615,16 @@ export class Config {
         // Initialize BaseLlmClient now that the ContentGenerator is available
         this.baseLlmClient = new BaseLlmClient(this.contentGenerator, this);
         const codeAssistServer = getCodeAssistServer(this);
-        if (codeAssistServer) {
-            if (codeAssistServer.projectId) {
-                await this.refreshUserQuota();
-            }
-            this.experimentsPromise = getExperiments(codeAssistServer)
-                .then((experiments) => {
-                this.setExperiments(experiments);
-                // If preview features have not been set and the user authenticated through Google, we enable preview based on remote config only if it's true
-                if (this.getPreviewFeatures() === undefined) {
-                    const remotePreviewFeatures = experiments.flags[ExperimentFlags.ENABLE_PREVIEW]?.boolValue;
-                    if (remotePreviewFeatures === true) {
-                        this.setPreviewFeatures(remotePreviewFeatures);
-                    }
-                }
-            })
-                .catch((e) => {
-                debugLogger.error('Failed to fetch experiments', e);
-            });
-        }
-        else {
-            this.experiments = undefined;
-            this.experimentsPromise = undefined;
+        if (codeAssistServer?.projectId) {
+            await this.refreshUserQuota();
         }
+        this.experimentsPromise = getExperiments(codeAssistServer)
+            .then((experiments) => {
+            this.setExperiments(experiments);
+        })
+            .catch((e) => {
+            debugLogger.error('Failed to fetch experiments', e);
+        });
         const authType = this.contentGeneratorConfig.authType;
         if (authType === AuthType.USE_GEMINI ||
             authType === AuthType.USE_VERTEX_AI) {
@@ -547,20 +634,29 @@ export class Config {
         if (!this.hasAccessToPreviewModel && isPreviewModel(this.model)) {
             this.setModel(DEFAULT_GEMINI_MODEL_AUTO);
         }
+        // Fetch admin controls
+        await this.ensureExperimentsLoaded();
+        const adminControlsEnabled = this.experiments?.flags[ExperimentFlags.ENABLE_ADMIN_CONTROLS]
+            ?.boolValue ?? false;
+        const adminControls = await fetchAdminControls(codeAssistServer, this.getRemoteAdminSettings(), adminControlsEnabled, (newSettings) => {
+            this.setRemoteAdminSettings(newSettings);
+            coreEvents.emitAdminSettingsChanged();
+        });
+        this.setRemoteAdminSettings(adminControls);
     }
     async getExperimentsAsync() {
         if (this.experiments) {
             return this.experiments;
         }
         const codeAssistServer = getCodeAssistServer(this);
-        if (codeAssistServer) {
-            return getExperiments(codeAssistServer);
-        }
-        return undefined;
+        return getExperiments(codeAssistServer);
     }
     getUserTier() {
         return this.contentGenerator?.userTier;
     }
+    getUserTierName() {
+        return this.contentGenerator?.userTierName;
+    }
     /**
      * Provides access to the BaseLlmClient for stateless LLM operations.
      */
@@ -588,6 +684,12 @@ export class Config {
     getTerminalBackground() {
         return this.terminalBackground;
     }
+    getLatestApiRequest() {
+        return this.latestApiRequest;
+    }
+    setLatestApiRequest(req) {
+        this.latestApiRequest = req;
+    }
     getRemoteAdminSettings() {
         return this.remoteAdminSettings;
     }
@@ -597,6 +699,9 @@ export class Config {
     shouldLoadMemoryFromIncludeDirectories() {
         return this.loadMemoryFromIncludeDirectories;
     }
+    getIncludeDirectoryTree() {
+        return this.includeDirectoryTree;
+    }
     getImportFormat() {
         return this.importFormat;
     }
@@ -609,6 +714,9 @@ export class Config {
     getModel() {
         return this.model;
     }
+    getDisableLoopDetection() {
+        return this.disableLoopDetection ?? false;
+    }
     setModel(newModel, isTemporary = true) {
         if (this.model !== newModel || this._activeModel !== newModel) {
             this.model = newModel;
@@ -642,6 +750,12 @@ export class Config {
     getFallbackModelHandler() {
         return this.fallbackModelHandler;
     }
+    setValidationHandler(handler) {
+        this.validationHandler = handler;
+    }
+    getValidationHandler() {
+        return this.validationHandler;
+    }
     resetTurn() {
         this.modelAvailabilityService.resetTurn();
     }
@@ -654,6 +768,69 @@ export class Config {
     getQuotaErrorOccurred() {
         return this.quotaErrorOccurred;
     }
+    setQuota(remaining, limit, modelId) {
+        const activeModel = modelId ?? this.getActiveModel();
+        if (remaining !== undefined && limit !== undefined) {
+            const current = this.modelQuotas.get(activeModel);
+            if (!current ||
+                current.remaining !== remaining ||
+                current.limit !== limit) {
+                this.modelQuotas.set(activeModel, { remaining, limit });
+                this.emitQuotaChangedEvent();
+            }
+        }
+    }
+    getPooledQuota() {
+        const model = this.getModel();
+        if (!isAutoModel(model)) {
+            return {};
+        }
+        const isPreview = model === PREVIEW_GEMINI_MODEL_AUTO ||
+            isPreviewModel(this.getActiveModel());
+        const proModel = isPreview ? PREVIEW_GEMINI_MODEL : DEFAULT_GEMINI_MODEL;
+        const flashModel = isPreview
+            ? PREVIEW_GEMINI_FLASH_MODEL
+            : DEFAULT_GEMINI_FLASH_MODEL;
+        const proQuota = this.modelQuotas.get(proModel);
+        const flashQuota = this.modelQuotas.get(flashModel);
+        if (proQuota || flashQuota) {
+            // For reset time, take the one that is furthest in the future (most conservative)
+            const resetTime = [proQuota?.resetTime, flashQuota?.resetTime]
+                .filter((t) => !!t)
+                .sort()
+                .reverse()[0];
+            return {
+                remaining: (proQuota?.remaining ?? 0) + (flashQuota?.remaining ?? 0),
+                limit: (proQuota?.limit ?? 0) + (flashQuota?.limit ?? 0),
+                resetTime,
+            };
+        }
+        return {};
+    }
+    getQuotaRemaining() {
+        const pooled = this.getPooledQuota();
+        if (pooled.remaining !== undefined) {
+            return pooled.remaining;
+        }
+        const primaryModel = resolveModel(this.getModel(), this.getGemini31LaunchedSync());
+        return this.modelQuotas.get(primaryModel)?.remaining;
+    }
+    getQuotaLimit() {
+        const pooled = this.getPooledQuota();
+        if (pooled.limit !== undefined) {
+            return pooled.limit;
+        }
+        const primaryModel = resolveModel(this.getModel(), this.getGemini31LaunchedSync());
+        return this.modelQuotas.get(primaryModel)?.limit;
+    }
+    getQuotaResetTime() {
+        const pooled = this.getPooledQuota();
+        if (pooled.resetTime !== undefined) {
+            return pooled.resetTime;
+        }
+        const primaryModel = resolveModel(this.getModel(), this.getGemini31LaunchedSync());
+        return this.modelQuotas.get(primaryModel)?.resetTime;
+    }
     getEmbeddingModel() {
         return this.embeddingModel;
     }
@@ -666,7 +843,8 @@ export class Config {
         return (!!sandboxConfig &&
             sandboxConfig.command === 'sandbox-exec' &&
             !!seatbeltProfile &&
-            seatbeltProfile.startsWith('restrictive-'));
+            (seatbeltProfile.startsWith('restrictive-') ||
+                seatbeltProfile.startsWith('strict-')));
     }
     getTargetDir() {
         return this.targetDir;
@@ -683,6 +861,9 @@ export class Config {
     getSkillManager() {
         return this.skillManager;
     }
+    getAcknowledgedAgentsService() {
+        return this.acknowledgedAgentsService;
+    }
     getToolRegistry() {
         return this.toolRegistry;
     }
@@ -698,25 +879,6 @@ export class Config {
     getQuestion() {
         return this.question;
     }
-    getPreviewFeatures() {
-        return this.previewFeatures;
-    }
-    setPreviewFeatures(previewFeatures) {
-        // No change in state, no action needed
-        if (this.previewFeatures === previewFeatures) {
-            return;
-        }
-        this.previewFeatures = previewFeatures;
-        const currentModel = this.getModel();
-        // Case 1: Disabling preview features while on a preview model
-        if (!previewFeatures && isPreviewModel(currentModel)) {
-            this.setModel(DEFAULT_GEMINI_MODEL_AUTO);
-        }
-        // Case 2: Enabling preview features while on the default auto model
-        else if (previewFeatures && currentModel === DEFAULT_GEMINI_MODEL_AUTO) {
-            this.setModel(PREVIEW_GEMINI_MODEL_AUTO);
-        }
-    }
     getHasAccessToPreviewModel() {
         return this.hasAccessToPreviewModel;
     }
@@ -732,7 +894,30 @@ export class Config {
             const quota = await codeAssistServer.retrieveUserQuota({
                 project: codeAssistServer.projectId,
             });
-            const hasAccess = quota.buckets?.some((b) => b.modelId === PREVIEW_GEMINI_MODEL) ?? false;
+            if (quota.buckets) {
+                this.lastRetrievedQuota = quota;
+                this.lastQuotaFetchTime = Date.now();
+                for (const bucket of quota.buckets) {
+                    if (bucket.modelId &&
+                        bucket.remainingAmount &&
+                        bucket.remainingFraction != null) {
+                        const remaining = parseInt(bucket.remainingAmount, 10);
+                        const limit = bucket.remainingFraction > 0
+                            ? Math.round(remaining / bucket.remainingFraction)
+                            : (this.modelQuotas.get(bucket.modelId)?.limit ?? 0);
+                        if (!isNaN(remaining) && Number.isFinite(limit) && limit > 0) {
+                            this.modelQuotas.set(bucket.modelId, {
+                                remaining,
+                                limit,
+                                resetTime: bucket.resetTime,
+                            });
+                        }
+                    }
+                }
+                this.emitQuotaChangedEvent();
+            }
+            const hasAccess = quota.buckets?.some((b) => b.modelId && isPreviewModel(b.modelId)) ??
+                false;
             this.setHasAccessToPreviewModel(hasAccess);
             return quota;
         }
@@ -741,6 +926,28 @@ export class Config {
             return undefined;
         }
     }
+    async refreshUserQuotaIfStale(staleMs = 30_000) {
+        const now = Date.now();
+        if (now - this.lastQuotaFetchTime > staleMs) {
+            return this.refreshUserQuota();
+        }
+        return this.lastRetrievedQuota;
+    }
+    getLastRetrievedQuota() {
+        return this.lastRetrievedQuota;
+    }
+    getRemainingQuotaForModel(modelId) {
+        const bucket = this.lastRetrievedQuota?.buckets?.find((b) => b.modelId === modelId);
+        if (!bucket)
+            return undefined;
+        return {
+            remainingAmount: bucket.remainingAmount
+                ? parseInt(bucket.remainingAmount, 10)
+                : undefined,
+            remainingFraction: bucket.remainingFraction,
+            resetTime: bucket.resetTime,
+        };
+    }
     getCoreTools() {
         return this.coreTools;
     }
@@ -749,11 +956,12 @@ export class Config {
     }
     /**
      * All the excluded tools from static configuration, loaded extensions, or
-     * other sources.
+     * other sources (like the Policy Engine).
      *
      * May change over time.
      */
     getExcludeTools() {
+        // Right now this is present for backward compatibility with settings.json exclude
         const excludeToolsSet = new Set([...(this.excludeTools ?? [])]);
         for (const extension of this.getExtensionLoader().getExtensions()) {
             if (!extension.isActive) {
@@ -763,6 +971,10 @@ export class Config {
                 excludeToolsSet.add(tool);
             }
         }
+        const policyExclusions = this.policyEngine.getExcludedTools();
+        for (const tool of policyExclusions) {
+            excludeToolsSet.add(tool);
+        }
         return excludeToolsSet;
     }
     getToolDiscoveryCommand() {
@@ -785,6 +997,12 @@ export class Config {
     getMcpEnabled() {
         return this.mcpEnabled;
     }
+    getMcpEnablementCallbacks() {
+        return this.mcpEnablementCallbacks;
+    }
+    getExtensionsEnabled() {
+        return this.extensionsEnabled;
+    }
     getMcpClientManager() {
         return this.mcpClientManager;
     }
@@ -806,15 +1024,30 @@ export class Config {
     }
     getUserMemory() {
         if (this.experimentalJitContext && this.contextManager) {
-            return [
-                this.contextManager.getGlobalMemory(),
-                this.contextManager.getEnvironmentMemory(),
-            ]
-                .filter(Boolean)
-                .join('\n\n');
+            return {
+                global: this.contextManager.getGlobalMemory(),
+                extension: this.contextManager.getExtensionMemory(),
+                project: this.contextManager.getEnvironmentMemory(),
+            };
         }
         return this.userMemory;
     }
+    /**
+     * Refreshes the MCP context, including memory, tools, and system instructions.
+     */
+    async refreshMcpContext() {
+        if (this.experimentalJitContext && this.contextManager) {
+            await this.contextManager.refresh();
+        }
+        else {
+            const { refreshServerHierarchicalMemory } = await import('../utils/memoryDiscovery.js');
+            await refreshServerHierarchicalMemory(this);
+        }
+        if (this.geminiClient?.isInitialized()) {
+            await this.geminiClient.setTools();
+            this.geminiClient.updateSystemInstruction();
+        }
+    }
     setUserMemory(newUserMemory) {
         this.userMemory = newUserMemory;
     }
@@ -830,6 +1063,34 @@ export class Config {
     isJitContextEnabled() {
         return this.experimentalJitContext;
     }
+    getToolOutputMaskingEnabled() {
+        return this.toolOutputMasking.enabled;
+    }
+    async getToolOutputMaskingConfig() {
+        await this.ensureExperimentsLoaded();
+        const remoteProtection = this.experiments?.flags[ExperimentFlags.MASKING_PROTECTION_THRESHOLD]
+            ?.intValue;
+        const remotePrunable = this.experiments?.flags[ExperimentFlags.MASKING_PRUNABLE_THRESHOLD]
+            ?.intValue;
+        const remoteProtectLatest = this.experiments?.flags[ExperimentFlags.MASKING_PROTECT_LATEST_TURN]
+            ?.boolValue;
+        const parsedProtection = remoteProtection
+            ? parseInt(remoteProtection, 10)
+            : undefined;
+        const parsedPrunable = remotePrunable
+            ? parseInt(remotePrunable, 10)
+            : undefined;
+        return {
+            enabled: this.toolOutputMasking.enabled,
+            toolProtectionThreshold: parsedProtection !== undefined && !isNaN(parsedProtection)
+                ? parsedProtection
+                : this.toolOutputMasking.toolProtectionThreshold,
+            minPrunableTokensThreshold: parsedPrunable !== undefined && !isNaN(parsedPrunable)
+                ? parsedPrunable
+                : this.toolOutputMasking.minPrunableTokensThreshold,
+            protectLatestTurn: remoteProtectLatest ?? this.toolOutputMasking.protectLatestTurn,
+        };
+    }
     getGeminiMdFileCount() {
         if (this.experimentalJitContext && this.contextManager) {
             return this.contextManager.getLoadedPaths().size;
@@ -855,11 +1116,72 @@ export class Config {
         if (!this.isTrustedFolder() && mode !== ApprovalMode.DEFAULT) {
             throw new Error('Cannot enable privileged approval modes in an untrusted folder.');
         }
+        const currentMode = this.getApprovalMode();
+        if (currentMode !== mode) {
+            this.logCurrentModeDuration(this.getApprovalMode());
+            logApprovalModeSwitch(this, new ApprovalModeSwitchEvent(currentMode, mode));
+            this.lastModeSwitchTime = Date.now();
+        }
         this.policyEngine.setApprovalMode(mode);
+        const isPlanModeTransition = currentMode !== mode &&
+            (currentMode === ApprovalMode.PLAN || mode === ApprovalMode.PLAN);
+        if (isPlanModeTransition) {
+            this.syncPlanModeTools();
+            this.updateSystemInstructionIfInitialized();
+        }
+    }
+    /**
+     * Synchronizes enter/exit plan mode tools based on current mode.
+     */
+    syncPlanModeTools() {
+        const isPlanMode = this.getApprovalMode() === ApprovalMode.PLAN;
+        const registry = this.getToolRegistry();
+        if (isPlanMode) {
+            if (registry.getTool(ENTER_PLAN_MODE_TOOL_NAME)) {
+                registry.unregisterTool(ENTER_PLAN_MODE_TOOL_NAME);
+            }
+            if (!registry.getTool(EXIT_PLAN_MODE_TOOL_NAME)) {
+                registry.registerTool(new ExitPlanModeTool(this, this.messageBus));
+            }
+        }
+        else {
+            if (registry.getTool(EXIT_PLAN_MODE_TOOL_NAME)) {
+                registry.unregisterTool(EXIT_PLAN_MODE_TOOL_NAME);
+            }
+            if (this.planEnabled) {
+                if (!registry.getTool(ENTER_PLAN_MODE_TOOL_NAME)) {
+                    registry.registerTool(new EnterPlanModeTool(this, this.messageBus));
+                }
+            }
+            else {
+                if (registry.getTool(ENTER_PLAN_MODE_TOOL_NAME)) {
+                    registry.unregisterTool(ENTER_PLAN_MODE_TOOL_NAME);
+                }
+            }
+        }
+        if (this.geminiClient?.isInitialized()) {
+            this.geminiClient.setTools().catch((err) => {
+                debugLogger.error('Failed to update tools', err);
+            });
+        }
+    }
+    /**
+     * Logs the duration of the current approval mode.
+     */
+    logCurrentModeDuration(mode) {
+        const now = Date.now();
+        const duration = now - this.lastModeSwitchTime;
+        logApprovalModeDuration(this, new ApprovalModeDurationEvent(mode, duration));
     }
     isYoloModeDisabled() {
         return this.disableYoloMode || !this.isTrustedFolder();
     }
+    getRawOutput() {
+        return this.rawOutput;
+    }
+    getAcceptRawOutputRisk() {
+        return this.acceptRawOutputRisk;
+    }
     getPendingIncludeDirectories() {
         return this.pendingIncludeDirectories;
     }
@@ -903,10 +1225,10 @@ export class Config {
      * Updates the system instruction with the latest user memory.
      * Whenever the user memory (GEMINI.md files) is updated.
      */
-    async updateSystemInstructionIfInitialized() {
+    updateSystemInstructionIfInitialized() {
         const geminiClient = this.getGeminiClient();
         if (geminiClient?.isInitialized()) {
-            await geminiClient.updateSystemInstruction();
+            geminiClient.updateSystemInstruction();
         }
     }
     getModelRouterService() {
@@ -918,8 +1240,8 @@ export class Config {
     getEnableRecursiveFileSearch() {
         return this.fileFiltering.enableRecursiveFileSearch;
     }
-    getFileFilteringDisableFuzzySearch() {
-        return this.fileFiltering.disableFuzzySearch;
+    getFileFilteringEnableFuzzySearch() {
+        return this.fileFiltering.enableFuzzySearch;
     }
     getFileFilteringRespectGitIgnore() {
         return this.fileFiltering.respectGitIgnore;
@@ -927,10 +1249,16 @@ export class Config {
     getFileFilteringRespectGeminiIgnore() {
         return this.fileFiltering.respectGeminiIgnore;
     }
+    getCustomIgnoreFilePaths() {
+        return this.fileFiltering.customIgnoreFilePaths;
+    }
     getFileFilteringOptions() {
         return {
             respectGitIgnore: this.fileFiltering.respectGitIgnore,
             respectGeminiIgnore: this.fileFiltering.respectGeminiIgnore,
+            maxFileCount: this.fileFiltering.maxFileCount,
+            searchTimeout: this.fileFiltering.searchTimeout,
+            customIgnoreFilePaths: this.fileFiltering.customIgnoreFilePaths,
         };
     }
     /**
@@ -961,7 +1289,11 @@ export class Config {
     }
     getFileService() {
         if (!this.fileDiscoveryService) {
-            this.fileDiscoveryService = new FileDiscoveryService(this.targetDir);
+            this.fileDiscoveryService = new FileDiscoveryService(this.targetDir, {
+                respectGitIgnore: this.fileFiltering.respectGitIgnore,
+                respectGeminiIgnore: this.fileFiltering.respectGeminiIgnore,
+                customIgnoreFilePaths: this.fileFiltering.customIgnoreFilePaths,
+            });
         }
         return this.fileDiscoveryService;
     }
@@ -997,12 +1329,30 @@ export class Config {
     getEnableExtensionReloading() {
         return this.enableExtensionReloading;
     }
+    getDisableLLMCorrection() {
+        return this.disableLLMCorrection;
+    }
+    isPlanEnabled() {
+        return this.planEnabled;
+    }
+    getApprovedPlanPath() {
+        return this.approvedPlanPath;
+    }
+    setApprovedPlanPath(path) {
+        this.approvedPlanPath = path;
+    }
     isAgentsEnabled() {
         return this.enableAgents;
     }
+    isEventDrivenSchedulerEnabled() {
+        return this.enableEventDrivenScheduler;
+    }
     getNoBrowser() {
         return this.noBrowser;
     }
+    getAgentsSettings() {
+        return this.agents;
+    }
     isBrowserLaunchSuppressed() {
         return this.getNoBrowser() || !shouldAttemptBrowserLaunch();
     }
@@ -1039,6 +1389,56 @@ export class Config {
     getFileSystemService() {
         return this.fileSystemService;
     }
+    /**
+     * Checks if a given absolute path is allowed for file system operations.
+     * A path is allowed if it's within the workspace context or the project's temporary directory.
+     *
+     * @param absolutePath The absolute path to check.
+     * @returns true if the path is allowed, false otherwise.
+     */
+    isPathAllowed(absolutePath) {
+        const realpath = (p) => {
+            let resolved;
+            try {
+                resolved = fs.realpathSync(p);
+            }
+            catch {
+                resolved = path.resolve(p);
+            }
+            return os.platform() === 'win32' ? resolved.toLowerCase() : resolved;
+        };
+        const resolvedPath = realpath(absolutePath);
+        const workspaceContext = this.getWorkspaceContext();
+        if (workspaceContext.isPathWithinWorkspace(resolvedPath)) {
+            return true;
+        }
+        const projectTempDir = this.storage.getProjectTempDir();
+        const resolvedTempDir = realpath(projectTempDir);
+        return isSubpath(resolvedTempDir, resolvedPath);
+    }
+    /**
+     * Validates if a path is allowed and returns a detailed error message if not.
+     *
+     * @param absolutePath The absolute path to validate.
+     * @param checkType The type of access to check ('read' or 'write'). Defaults to 'write' for safety.
+     * @returns An error message string if the path is disallowed, null otherwise.
+     */
+    validatePathAccess(absolutePath, checkType = 'write') {
+        // For read operations, check read-only paths first
+        if (checkType === 'read') {
+            if (this.getWorkspaceContext().isPathReadable(absolutePath)) {
+                return null;
+            }
+        }
+        // Then check standard allowed paths (Workspace + Temp)
+        // This covers 'write' checks and acts as a fallback/temp-dir check for 'read'
+        if (this.isPathAllowed(absolutePath)) {
+            return null;
+        }
+        const workspaceDirs = this.getWorkspaceContext().getDirectories();
+        const projectTempDir = this.storage.getProjectTempDir();
+        return `Path not in workspace: Attempted path "${absolutePath}" resolves outside the allowed workspace directories: ${workspaceDirs.join(', ')} or the project temp directory: ${projectTempDir}`;
+    }
     /**
      * Set a custom FileSystemService
      */
@@ -1061,6 +1461,19 @@ export class Config {
         await this.ensureExperimentsLoaded();
         return this.experiments?.flags[ExperimentFlags.USER_CACHING]?.boolValue;
     }
+    async getNumericalRoutingEnabled() {
+        await this.ensureExperimentsLoaded();
+        return !!this.experiments?.flags[ExperimentFlags.ENABLE_NUMERICAL_ROUTING]
+            ?.boolValue;
+    }
+    async getClassifierThreshold() {
+        await this.ensureExperimentsLoaded();
+        const flag = this.experiments?.flags[ExperimentFlags.CLASSIFIER_THRESHOLD];
+        if (flag?.intValue !== undefined) {
+            return parseInt(flag.intValue, 10);
+        }
+        return flag?.floatValue;
+    }
     async getBannerTextNoCapacityIssues() {
         await this.ensureExperimentsLoaded();
         return (this.experiments?.flags[ExperimentFlags.BANNER_TEXT_NO_CAPACITY_ISSUES]
@@ -1071,6 +1484,30 @@ export class Config {
         return (this.experiments?.flags[ExperimentFlags.BANNER_TEXT_CAPACITY_ISSUES]
             ?.stringValue ?? '');
     }
+    /**
+     * Returns whether Gemini 3.1 has been launched.
+     * This method is async and ensures that experiments are loaded before returning the result.
+     */
+    async getGemini31Launched() {
+        await this.ensureExperimentsLoaded();
+        return this.getGemini31LaunchedSync();
+    }
+    /**
+     * Returns whether Gemini 3.1 has been launched.
+     *
+     * Note: This method should only be called after startup, once experiments have been loaded.
+     * If you need to call this during startup or from an async context, use
+     * getGemini31Launched instead.
+     */
+    getGemini31LaunchedSync() {
+        const authType = this.contentGeneratorConfig?.authType;
+        if (authType === AuthType.USE_GEMINI ||
+            authType === AuthType.USE_VERTEX_AI) {
+            return true;
+        }
+        return (this.experiments?.flags[ExperimentFlags.GEMINI_3_1_PRO_LAUNCHED]
+            ?.boolValue ?? false);
+    }
     async ensureExperimentsLoaded() {
         if (!this.experimentsPromise) {
             return;
@@ -1100,18 +1537,37 @@ export class Config {
         if (this.onReload) {
             const refreshed = await this.onReload();
             this.disabledSkills = refreshed.disabledSkills ?? [];
+            this.getSkillManager().setAdminSettings(refreshed.adminSkillsEnabled ?? this.adminSkillsEnabled);
         }
-        await this.getSkillManager().discoverSkills(this.storage, this.getExtensions());
-        this.getSkillManager().setDisabledSkills(this.disabledSkills);
-        // Re-register ActivateSkillTool to update its schema with the newly discovered skills
-        if (this.getSkillManager().getSkills().length > 0) {
-            this.getToolRegistry().registerTool(new ActivateSkillTool(this, this.messageBus));
+        if (this.getSkillManager().isAdminEnabled()) {
+            await this.getSkillManager().discoverSkills(this.storage, this.getExtensions(), this.isTrustedFolder());
+            this.getSkillManager().setDisabledSkills(this.disabledSkills);
+            // Re-register ActivateSkillTool to update its schema with the newly discovered skills
+            if (this.getSkillManager().getSkills().length > 0) {
+                this.getToolRegistry().unregisterTool(ActivateSkillTool.Name);
+                this.getToolRegistry().registerTool(new ActivateSkillTool(this, this.messageBus));
+            }
+            else {
+                this.getToolRegistry().unregisterTool(ActivateSkillTool.Name);
+            }
         }
         else {
+            this.getSkillManager().clearSkills();
             this.getToolRegistry().unregisterTool(ActivateSkillTool.Name);
         }
         // Notify the client that system instructions might need updating
-        await this.updateSystemInstructionIfInitialized();
+        this.updateSystemInstructionIfInitialized();
+    }
+    /**
+     * Reloads agent settings.
+     */
+    async reloadAgents() {
+        if (this.onReload) {
+            const refreshed = await this.onReload();
+            if (refreshed.agents) {
+                this.agents = refreshed.agents;
+            }
+        }
     }
     isInteractive() {
         return this.interactive;
@@ -1119,6 +1575,9 @@ export class Config {
     getUseRipgrep() {
         return this.useRipgrep;
     }
+    getUseBackgroundColor() {
+        return this.useBackgroundColor;
+    }
     getEnableInteractiveShell() {
         return this.enableInteractiveShell;
     }
@@ -1156,17 +1615,14 @@ export class Config {
     getEnablePromptCompletion() {
         return this.enablePromptCompletion;
     }
-    getEnableToolOutputTruncation() {
-        return this.enableToolOutputTruncation;
-    }
     getTruncateToolOutputThreshold() {
         return Math.min(
         // Estimate remaining context window in characters (1 token ~= 4 chars).
         4 *
             (tokenLimit(this.model) - uiTelemetryService.getLastPromptTokenCount()), this.truncateToolOutputThreshold);
     }
-    getTruncateToolOutputLines() {
-        return this.truncateToolOutputLines;
+    getNextCompressionTruncationId() {
+        return ++this.compressionTruncationCounter;
     }
     getUseWriteTodos() {
         return this.useWriteTodos;
@@ -1195,19 +1651,15 @@ export class Config {
     getEnableHooks() {
         return this.enableHooks;
     }
-    getCodebaseInvestigatorSettings() {
-        return this.codebaseInvestigatorSettings;
-    }
-    getIntrospectionAgentSettings() {
-        return this.introspectionAgentSettings;
+    getEnableHooksUI() {
+        return this.enableHooksUI;
     }
     async createToolRegistry() {
         const registry = new ToolRegistry(this, this.messageBus);
         // helper to create & register core tools that are enabled
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const registerCoreTool = (ToolClass, ...args) => {
-            const className = ToolClass.name;
-            const toolName = ToolClass.Name || className;
+        const maybeRegister = (toolClass, registerFn) => {
+            const className = toolClass.name;
+            const toolName = toolClass.Name || className;
             const coreTools = this.getCoreTools();
             // On some platforms, the className can be minified to _ClassName.
             const normalizedClassName = className.replace(/^_+/, '');
@@ -1219,13 +1671,11 @@ export class Config {
                     tool.startsWith(`${normalizedClassName}(`));
             }
             if (isEnabled) {
-                // Pass message bus to tools (required for policy engine integration)
-                const toolArgs = [...args, this.getMessageBus()];
-                registry.registerTool(new ToolClass(...toolArgs));
+                registerFn();
             }
         };
-        registerCoreTool(LSTool, this);
-        registerCoreTool(ReadFileTool, this);
+        maybeRegister(LSTool, () => registry.registerTool(new LSTool(this, this.messageBus)));
+        maybeRegister(ReadFileTool, () => registry.registerTool(new ReadFileTool(this, this.messageBus)));
         if (this.getUseRipgrep()) {
             let useRipgrep = false;
             let errorString = undefined;
@@ -1236,43 +1686,58 @@ export class Config {
                 errorString = String(error);
             }
             if (useRipgrep) {
-                registerCoreTool(RipGrepTool, this);
+                maybeRegister(RipGrepTool, () => registry.registerTool(new RipGrepTool(this, this.messageBus)));
             }
             else {
                 logRipgrepFallback(this, new RipgrepFallbackEvent(errorString));
-                registerCoreTool(GrepTool, this);
+                maybeRegister(GrepTool, () => registry.registerTool(new GrepTool(this, this.messageBus)));
             }
         }
         else {
-            registerCoreTool(GrepTool, this);
-        }
-        registerCoreTool(GlobTool, this);
-        registerCoreTool(ActivateSkillTool, this);
-        registerCoreTool(EditTool, this);
-        registerCoreTool(WriteFileTool, this);
-        registerCoreTool(WebFetchTool, this);
-        registerCoreTool(ShellTool, this);
-        registerCoreTool(MemoryTool);
-        registerCoreTool(WebSearchTool, this);
+            maybeRegister(GrepTool, () => registry.registerTool(new GrepTool(this, this.messageBus)));
+        }
+        maybeRegister(GlobTool, () => registry.registerTool(new GlobTool(this, this.messageBus)));
+        maybeRegister(ActivateSkillTool, () => registry.registerTool(new ActivateSkillTool(this, this.messageBus)));
+        maybeRegister(EditTool, () => registry.registerTool(new EditTool(this, this.messageBus)));
+        maybeRegister(WriteFileTool, () => registry.registerTool(new WriteFileTool(this, this.messageBus)));
+        maybeRegister(WebFetchTool, () => registry.registerTool(new WebFetchTool(this, this.messageBus)));
+        maybeRegister(ShellTool, () => registry.registerTool(new ShellTool(this, this.messageBus)));
+        maybeRegister(MemoryTool, () => registry.registerTool(new MemoryTool(this.messageBus)));
+        maybeRegister(WebSearchTool, () => registry.registerTool(new WebSearchTool(this, this.messageBus)));
+        maybeRegister(AskUserTool, () => registry.registerTool(new AskUserTool(this.messageBus)));
         if (this.getUseWriteTodos()) {
-            registerCoreTool(WriteTodosTool);
+            maybeRegister(WriteTodosTool, () => registry.registerTool(new WriteTodosTool(this.messageBus)));
         }
-        // Register Subagents as Tools
-        // Register DelegateToAgentTool if agents are enabled
-        if (this.isAgentsEnabled() ||
-            this.getCodebaseInvestigatorSettings().enabled) {
-            // Check if the delegate tool itself is allowed (if allowedTools is set)
-            const allowedTools = this.getAllowedTools();
-            const isAllowed = !allowedTools || allowedTools.includes(DELEGATE_TO_AGENT_TOOL_NAME);
-            if (isAllowed) {
-                const delegateTool = new DelegateToAgentTool(this.agentRegistry, this, this.getMessageBus());
-                registry.registerTool(delegateTool);
-            }
+        if (this.isPlanEnabled()) {
+            maybeRegister(ExitPlanModeTool, () => registry.registerTool(new ExitPlanModeTool(this, this.messageBus)));
+            maybeRegister(EnterPlanModeTool, () => registry.registerTool(new EnterPlanModeTool(this, this.messageBus)));
         }
+        // Register Subagents as Tools
+        this.registerSubAgentTools(registry);
         await registry.discoverAllTools();
         registry.sortTools();
         return registry;
     }
+    /**
+     * Registers SubAgentTools for all available agents.
+     */
+    registerSubAgentTools(registry) {
+        const agentsOverrides = this.getAgentsSettings().overrides ?? {};
+        if (this.isAgentsEnabled() ||
+            agentsOverrides['codebase_investigator']?.enabled !== false ||
+            agentsOverrides['cli_help']?.enabled !== false) {
+            const definitions = this.agentRegistry.getAllDefinitions();
+            for (const definition of definitions) {
+                try {
+                    const tool = new SubagentTool(definition, this, this.getMessageBus());
+                    registry.registerTool(tool);
+                }
+                catch (e) {
+                    debugLogger.warn(`Failed to register tool for agent ${definition.name}: ${getErrorMessage(e)}`);
+                }
+            }
+        }
+    }
     /**
      * Get the hook system instance
      */
@@ -1291,6 +1756,14 @@ export class Config {
     getProjectHooks() {
         return this.projectHooks;
     }
+    /**
+     * Update the list of disabled hooks dynamically.
+     * This is used to keep the running system in sync with settings changes
+     * without risk of loading new hook definitions into memory.
+     */
+    updateDisabledHooks(disabledHooks) {
+        this.disabledHooks = disabledHooks;
+    }
     /**
      * Get disabled hooks list
      */
@@ -1347,6 +1820,32 @@ export class Config {
         });
         debugLogger.debug('Experiments loaded', summaryString);
     }
+    onAgentsRefreshed = async () => {
+        if (this.toolRegistry) {
+            this.registerSubAgentTools(this.toolRegistry);
+        }
+        // Propagate updates to the active chat session
+        const client = this.getGeminiClient();
+        if (client?.isInitialized()) {
+            await client.setTools();
+            client.updateSystemInstruction();
+        }
+        else {
+            debugLogger.debug('[Config] GeminiClient not initialized; skipping live prompt/tool refresh.');
+        }
+    };
+    /**
+     * Disposes of resources and removes event listeners.
+     */
+    async dispose() {
+        this.logCurrentModeDuration(this.getApprovalMode());
+        coreEvents.off(CoreEvent.AgentsRefreshed, this.onAgentsRefreshed);
+        this.agentRegistry?.dispose();
+        this.geminiClient?.dispose();
+        if (this.mcpClientManager) {
+            await this.mcpClientManager.stop();
+        }
+    }
 }
 // Export model constants for use in CLI
 export { DEFAULT_GEMINI_FLASH_MODEL };