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

package/dist/src/config/config.js

@@ -8,14 +8,15 @@ import { inspect } from 'node:util';
 import process from 'node:process';
 import { AuthType, createContentGenerator, createContentGeneratorConfig, } from '../core/contentGenerator.js';
 import { PromptRegistry } from '../prompts/prompt-registry.js';
+import { ResourceRegistry } from '../resources/resource-registry.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
 import { LSTool } from '../tools/ls.js';
 import { ReadFileTool } from '../tools/read-file.js';
 import { GrepTool } from '../tools/grep.js';
 import { canUseRipgrep, RipGrepTool } from '../tools/ripGrep.js';
 import { GlobTool } from '../tools/glob.js';
+import { ActivateSkillTool } from '../tools/activate-skill.js';
 import { EditTool } from '../tools/edit.js';
-import { SmartEditTool } from '../tools/smart-edit.js';
 import { ShellTool } from '../tools/shell.js';
 import { WriteFileTool } from '../tools/write-file.js';
 import { WebFetchTool } from '../tools/web-fetch.js';
@@ -26,15 +27,15 @@ 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, DEFAULT_THINKING_MODE, } from './models.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 { 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 } from '../telemetry/loggers.js';
-import { RipgrepFallbackEvent } from '../telemetry/types.js';
+import { logRipgrepFallback, logFlashFallback } from '../telemetry/loggers.js';
+import { RipgrepFallbackEvent, FlashFallbackEvent, } from '../telemetry/types.js';
 import { ModelAvailabilityService } from '../availability/modelAvailabilityService.js';
 import { ModelRouterService } from '../routing/modelRouterService.js';
 import { OutputFormat } from '../output/types.js';
@@ -46,17 +47,18 @@ 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 { setGlobalProxy } from '../utils/fetch.js';
-import { SubagentToolWrapper } from '../agents/subagent-tool-wrapper.js';
+import { DelegateToAgentTool } from '../agents/delegate-to-agent-tool.js';
+import { DELEGATE_TO_AGENT_TOOL_NAME } from '../tools/tool-names.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';
-export { ApprovalMode };
 import { DEFAULT_FILE_FILTERING_OPTIONS, DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, } from './constants.js';
 import { SimpleExtensionLoader, } from '../utils/extensionLoader.js';
 import { McpClientManager } from '../tools/mcp-client-manager.js';
@@ -73,6 +75,7 @@ export class MCPServerConfig {
     httpUrl;
     headers;
     tcp;
+    type;
     timeout;
     trust;
     description;
@@ -92,6 +95,12 @@ export class MCPServerConfig {
     httpUrl, headers, 
     // For websocket transport
     tcp, 
+    // Transport type (optional, for use with 'url' field)
+    // When set to 'http', uses StreamableHTTPClientTransport
+    // When set to 'sse', uses SSEClientTransport
+    // When omitted, auto-detects transport type
+    // Note: 'httpUrl' is deprecated in favor of 'url' + 'type'
+    type, 
     // Common
     timeout, trust, 
     // Metadata
@@ -112,6 +121,7 @@ export class MCPServerConfig {
         this.httpUrl = httpUrl;
         this.headers = headers;
         this.tcp = tcp;
+        this.type = type;
         this.timeout = timeout;
         this.trust = trust;
         this.description = description;
@@ -135,8 +145,13 @@ export class Config {
     mcpClientManager;
     allowedMcpServers;
     blockedMcpServers;
+    allowedEnvironmentVariables;
+    blockedEnvironmentVariables;
+    enableEnvironmentVariableRedaction;
     promptRegistry;
+    resourceRegistry;
     agentRegistry;
+    skillManager;
     sessionId;
     fileSystemService;
     contentGeneratorConfig;
@@ -154,11 +169,12 @@ export class Config {
     toolDiscoveryCommand;
     toolCallCommand;
     mcpServerCommand;
+    mcpEnabled;
+    extensionsEnabled;
     mcpServers;
     userMemory;
     geminiMdFileCount;
     geminiMdFilePaths;
-    approvalMode;
     showMemoryUsage;
     accessibility;
     telemetrySettings;
@@ -180,10 +196,11 @@ export class Config {
     bugCommand;
     model;
     previewFeatures;
+    hasAccessToPreviewModel = false;
     noBrowser;
     folderTrust;
     ideMode;
-    inFallbackMode = false;
+    _activeModel;
     maxSessionTurns;
     listSessions;
     deleteSession;
@@ -215,13 +232,12 @@ export class Config {
     storage;
     fileExclusions;
     eventEmitter;
-    useSmartEdit;
     useWriteTodos;
     messageBus;
     policyEngine;
     outputSettings;
-    enableMessageBusIntegration;
     codebaseInvestigatorSettings;
+    cliHelpAgentSettings;
     continueOnFailedApiCall;
     retryFetchErrors;
     enableShellOutputEfficiency;
@@ -231,15 +247,26 @@ export class Config {
     disableYoloMode;
     pendingIncludeDirectories;
     enableHooks;
+    enableHooksUI;
     hooks;
+    projectHooks;
+    disabledHooks;
     experiments;
     experimentsPromise;
     hookSystem;
-    previewModelFallbackMode = false;
-    previewModelBypassMode = false;
-    enableModelAvailabilityService;
+    onModelChange;
+    onReload;
+    enableAgents;
+    agents;
+    skillsSupport;
+    disabledSkills;
+    adminSkillsEnabled;
     experimentalJitContext;
+    disableLLMCorrection;
     contextManager;
+    terminalBackground = undefined;
+    remoteAdminSettings;
+    latestApiRequest;
     constructor(params) {
         this.sessionId = params.sessionId;
         this.embeddingModel =
@@ -259,12 +286,17 @@ export class Config {
         this.toolCallCommand = params.toolCallCommand;
         this.mcpServerCommand = params.mcpServerCommand;
         this.mcpServers = params.mcpServers;
+        this.mcpEnabled = params.mcpEnabled ?? true;
+        this.extensionsEnabled = params.extensionsEnabled ?? true;
         this.allowedMcpServers = params.allowedMcpServers ?? [];
         this.blockedMcpServers = params.blockedMcpServers ?? [];
+        this.allowedEnvironmentVariables = params.allowedEnvironmentVariables ?? [];
+        this.blockedEnvironmentVariables = params.blockedEnvironmentVariables ?? [];
+        this.enableEnvironmentVariableRedaction =
+            params.enableEnvironmentVariableRedaction ?? false;
         this.userMemory = params.userMemory ?? '';
         this.geminiMdFileCount = params.geminiMdFileCount ?? 0;
         this.geminiMdFilePaths = params.geminiMdFilePaths ?? [];
-        this.approvalMode = params.approvalMode ?? ApprovalMode.DEFAULT;
         this.showMemoryUsage = params.showMemoryUsage ?? false;
         this.accessibility = params.accessibility ?? {};
         this.telemetrySettings = {
@@ -275,6 +307,7 @@ export class Config {
             logPrompts: params.telemetry?.logPrompts ?? true,
             outfile: params.telemetry?.outfile,
             useCollector: params.telemetry?.useCollector,
+            useCliAuth: params.telemetry?.useCliAuth,
         };
         this.usageStatisticsEnabled = params.usageStatisticsEnabled ?? true;
         this.fileFiltering = {
@@ -295,11 +328,16 @@ export class Config {
         this.fileDiscoveryService = params.fileDiscoveryService ?? null;
         this.bugCommand = params.bugCommand;
         this.model = params.model;
-        this.enableModelAvailabilityService =
-            params.enableModelAvailabilityService ?? false;
-        this.experimentalJitContext = params.experimentalJitContext ?? false;
+        this._activeModel = params.model;
+        this.enableAgents = params.enableAgents ?? false;
+        this.agents = params.agents ?? {};
+        this.disableLLMCorrection = params.disableLLMCorrection ?? false;
+        this.skillsSupport = params.skillsSupport ?? false;
+        this.disabledSkills = params.disabledSkills ?? [];
+        this.adminSkillsEnabled = params.adminSkillsEnabled ?? true;
         this.modelAvailabilityService = new ModelAvailabilityService();
         this.previewFeatures = params.previewFeatures ?? undefined;
+        this.experimentalJitContext = params.experimentalJitContext ?? false;
         this.maxSessionTurns = params.maxSessionTurns ?? -1;
         this.experimentalZedIntegration =
             params.experimentalZedIntegration ?? false;
@@ -329,6 +367,7 @@ export class Config {
             terminalHeight: params.shellExecutionConfig?.terminalHeight ?? 24,
             showColor: params.shellExecutionConfig?.showColor ?? false,
             pager: params.shellExecutionConfig?.pager ?? 'cat',
+            sanitizationConfig: this.sanitizationConfig,
         };
         this.truncateToolOutputThreshold =
             params.truncateToolOutputThreshold ??
@@ -336,24 +375,26 @@ export class Config {
         this.truncateToolOutputLines =
             params.truncateToolOutputLines ?? DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES;
         this.enableToolOutputTruncation = params.enableToolOutputTruncation ?? true;
-        this.useSmartEdit = params.useSmartEdit ?? true;
-        this.useWriteTodos = params.useWriteTodos ?? true;
+        // // TODO(joshualitt): Re-evaluate the todo tool for 3 family.
+        this.useWriteTodos = isPreviewModel(this.model)
+            ? false
+            : (params.useWriteTodos ?? true);
+        this.enableHooksUI = params.enableHooksUI ?? true;
         this.enableHooks = params.enableHooks ?? false;
-        // Enable MessageBus integration if:
-        // 1. Explicitly enabled via setting, OR
-        // 2. Hooks are enabled and hooks are configured
-        const hasHooks = params.hooks && Object.keys(params.hooks).length > 0;
-        const hooksNeedMessageBus = this.enableHooks && hasHooks;
-        this.enableMessageBusIntegration =
-            params.enableMessageBusIntegration ??
-                (hooksNeedMessageBus ? true : 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 ?? DEFAULT_GEMINI_MODEL,
+            model: params.codebaseInvestigatorSettings?.model,
+        };
+        this.cliHelpAgentSettings = {
+            enabled: params.cliHelpAgentSettings?.enabled ?? true,
         };
         this.continueOnFailedApiCall = params.continueOnFailedApiCall ?? true;
         this.enableShellOutputEfficiency =
@@ -368,19 +409,27 @@ export class Config {
         this.enablePromptCompletion = params.enablePromptCompletion ?? false;
         this.fileExclusions = new FileExclusions(this);
         this.eventEmitter = params.eventEmitter;
-        this.policyEngine = new PolicyEngine(params.policyEngineConfig);
+        this.policyEngine = new PolicyEngine({
+            ...params.policyEngineConfig,
+            approvalMode: params.approvalMode ?? params.policyEngineConfig?.approvalMode,
+        });
         this.messageBus = new MessageBus(this.policyEngine, this.debugMode);
+        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.experiments = params.experiments;
+        this.onModelChange = params.onModelChange;
+        this.onReload = params.onReload;
         if (params.contextFileName) {
             setGeminiMdFilename(params.contextFileName);
         }
         if (this.telemetrySettings.enabled) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             initializeTelemetry(this);
         }
         const proxy = this.getProxy();
@@ -402,11 +451,19 @@ export class Config {
         // TODO(12593): Fix the settings loading logic to properly merge defaults and
         // remove this hack.
         let modelConfigServiceConfig = params.modelConfigServiceConfig;
-        if (modelConfigServiceConfig && !modelConfigServiceConfig.aliases) {
-            modelConfigServiceConfig = {
-                ...modelConfigServiceConfig,
-                aliases: DEFAULT_MODEL_CONFIGS.aliases,
-            };
+        if (modelConfigServiceConfig) {
+            if (!modelConfigServiceConfig.aliases) {
+                modelConfigServiceConfig = {
+                    ...modelConfigServiceConfig,
+                    aliases: DEFAULT_MODEL_CONFIGS.aliases,
+                };
+            }
+            if (!modelConfigServiceConfig.overrides) {
+                modelConfigServiceConfig = {
+                    ...modelConfigServiceConfig,
+                    overrides: DEFAULT_MODEL_CONFIGS.overrides,
+                };
+            }
         }
         this.modelConfigService = new ModelConfigService(modelConfigServiceConfig ?? DEFAULT_MODEL_CONFIGS);
     }
@@ -425,8 +482,10 @@ export class Config {
             await this.getGitService();
         }
         this.promptRegistry = new PromptRegistry();
+        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);
@@ -436,13 +495,26 @@ export class Config {
             await this.getExtensionLoader().start(this),
         ]);
         initMcpHandle?.end();
+        if (this.skillsSupport) {
+            this.getSkillManager().setAdminSettings(this.adminSkillsEnabled);
+            if (this.adminSkillsEnabled) {
+                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().unregisterTool(ActivateSkillTool.Name);
+                    this.getToolRegistry().registerTool(new ActivateSkillTool(this, this.messageBus));
+                }
+            }
+        }
         // Initialize hook system if enabled
-        if (this.enableHooks) {
+        if (this.getEnableHooks()) {
             this.hookSystem = new HookSystem(this);
             await this.hookSystem.initialize();
         }
         if (this.experimentalJitContext) {
             this.contextManager = new ContextManager(this);
+            await this.contextManager.refresh();
         }
         await this.geminiClient.initialize();
     }
@@ -450,6 +522,8 @@ export class Config {
         return this.contentGenerator;
     }
     async refreshAuth(authMethod, displayMessage) {
+        // Reset availability service when switching auth
+        this.modelAvailabilityService.reset();
         // Vertex and Genai have incompatible encryption and sending history with
         // thoughtSignature from Genai to Vertex will fail, we need to strip them
         if (this.contentGeneratorConfig?.authType === AuthType.USE_GEMINI &&
@@ -457,6 +531,8 @@ export class Config {
             // Restore the conversation history to the new client
             this.geminiClient.stripThoughtsFromHistory();
         }
+        // Reset availability status when switching auth (e.g. from limited key to OAuth)
+        this.modelAvailabilityService.reset();
         const newContentGeneratorConfig = await createContentGeneratorConfig(this, authMethod, {
             clientId: this.keycloakClientId,
             deviceEndpoint: this.keycloakDeviceEndpoint,
@@ -467,40 +543,44 @@ export class Config {
         this.contentGeneratorConfig = newContentGeneratorConfig;
         // Initialize BaseLlmClient now that the ContentGenerator is available
         this.baseLlmClient = new BaseLlmClient(this.contentGenerator, this);
-        const previewFeatures = this.getPreviewFeatures();
         const codeAssistServer = getCodeAssistServer(this);
-        if (codeAssistServer) {
-            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 (previewFeatures === undefined) {
-                    const remotePreviewFeatures = experiments.flags[ExperimentFlags.ENABLE_PREVIEW]?.boolValue;
-                    if (remotePreviewFeatures === true) {
-                        this.setPreviewFeatures(remotePreviewFeatures);
-                    }
+        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);
-            });
+            }
+        })
+            .catch((e) => {
+            debugLogger.error('Failed to fetch experiments', e);
+        });
+        const authType = this.contentGeneratorConfig.authType;
+        if (authType === AuthType.USE_GEMINI ||
+            authType === AuthType.USE_VERTEX_AI) {
+            this.setHasAccessToPreviewModel(true);
         }
-        else {
-            this.experiments = undefined;
-            this.experimentsPromise = undefined;
+        // PATCH: If preview features are enabled, we assume access to the preview model.
+        // TODO(joshualitt): Revisit this logic to ensure that the user has access to
+        // the preview model through a proper quota check.
+        if (!this.getPreviewFeatures() &&
+            !this.hasAccessToPreviewModel &&
+            isPreviewModel(this.model)) {
+            this.setModel(DEFAULT_GEMINI_MODEL_AUTO);
         }
-        // Reset the session flag since we're explicitly changing auth and using default model
-        this.inFallbackMode = false;
     }
     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;
@@ -526,6 +606,24 @@ export class Config {
     setSessionId(sessionId) {
         this.sessionId = sessionId;
     }
+    setTerminalBackground(terminalBackground) {
+        this.terminalBackground = terminalBackground;
+    }
+    getTerminalBackground() {
+        return this.terminalBackground;
+    }
+    getLatestApiRequest() {
+        return this.latestApiRequest;
+    }
+    setLatestApiRequest(req) {
+        this.latestApiRequest = req;
+    }
+    getRemoteAdminSettings() {
+        return this.remoteAdminSettings;
+    }
+    setRemoteAdminSettings(settings) {
+        this.remoteAdminSettings = settings;
+    }
     shouldLoadMemoryFromIncludeDirectories() {
         return this.loadMemoryFromIncludeDirectories;
     }
@@ -541,18 +639,32 @@ export class Config {
     getModel() {
         return this.model;
     }
-    setModel(newModel) {
-        if (this.model !== newModel || this.inFallbackMode) {
+    setModel(newModel, isTemporary = true) {
+        if (this.model !== newModel || this._activeModel !== newModel) {
             this.model = newModel;
+            // When the user explicitly sets a model, that becomes the active model.
+            this._activeModel = newModel;
             coreEvents.emitModelChanged(newModel);
+            if (this.onModelChange && !isTemporary) {
+                this.onModelChange(newModel);
+            }
         }
-        this.setFallbackMode(false);
+        this.modelAvailabilityService.reset();
     }
-    isInFallbackMode() {
-        return this.inFallbackMode;
+    activateFallbackMode(model) {
+        this.setModel(model, true);
+        const authType = this.getContentGeneratorConfig()?.authType;
+        if (authType) {
+            logFlashFallback(this, new FlashFallbackEvent(authType));
+        }
     }
-    setFallbackMode(active) {
-        this.inFallbackMode = active;
+    getActiveModel() {
+        return this._activeModel ?? this.model;
+    }
+    setActiveModel(model) {
+        if (this._activeModel !== model) {
+            this._activeModel = model;
+        }
     }
     setFallbackModelHandler(handler) {
         this.fallbackModelHandler = handler;
@@ -560,17 +672,8 @@ export class Config {
     getFallbackModelHandler() {
         return this.fallbackModelHandler;
     }
-    isPreviewModelFallbackMode() {
-        return this.previewModelFallbackMode;
-    }
-    setPreviewModelFallbackMode(active) {
-        this.previewModelFallbackMode = active;
-    }
-    isPreviewModelBypassMode() {
-        return this.previewModelBypassMode;
-    }
-    setPreviewModelBypassMode(active) {
-        this.previewModelBypassMode = active;
+    resetTurn() {
+        this.modelAvailabilityService.resetTurn();
     }
     getMaxSessionTurns() {
         return this.maxSessionTurns;
@@ -613,6 +716,12 @@ export class Config {
     getPromptRegistry() {
         return this.promptRegistry;
     }
+    getSkillManager() {
+        return this.skillManager;
+    }
+    getResourceRegistry() {
+        return this.resourceRegistry;
+    }
     getDebugMode() {
         return this.debugMode;
     }
@@ -623,7 +732,44 @@ export class Config {
         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;
+    }
+    setHasAccessToPreviewModel(hasAccess) {
+        this.hasAccessToPreviewModel = hasAccess;
+    }
+    async refreshUserQuota() {
+        const codeAssistServer = getCodeAssistServer(this);
+        if (!codeAssistServer || !codeAssistServer.projectId) {
+            return undefined;
+        }
+        try {
+            const quota = await codeAssistServer.retrieveUserQuota({
+                project: codeAssistServer.projectId,
+            });
+            const hasAccess = quota.buckets?.some((b) => b.modelId === PREVIEW_GEMINI_MODEL) ?? false;
+            this.setHasAccessToPreviewModel(hasAccess);
+            return quota;
+        }
+        catch (e) {
+            debugLogger.debug('Failed to retrieve user quota', e);
+            return undefined;
+        }
     }
     getCoreTools() {
         return this.coreTools;
@@ -666,6 +812,12 @@ export class Config {
     getMcpServers() {
         return this.mcpServers;
     }
+    getMcpEnabled() {
+        return this.mcpEnabled;
+    }
+    getExtensionsEnabled() {
+        return this.extensionsEnabled;
+    }
     getMcpClientManager() {
         return this.mcpClientManager;
     }
@@ -675,10 +827,25 @@ export class Config {
     getBlockedMcpServers() {
         return this.blockedMcpServers;
     }
+    get sanitizationConfig() {
+        return {
+            allowedEnvironmentVariables: this.allowedEnvironmentVariables,
+            blockedEnvironmentVariables: this.blockedEnvironmentVariables,
+            enableEnvironmentVariableRedaction: this.enableEnvironmentVariableRedaction,
+        };
+    }
     setMcpServers(mcpServers) {
         this.mcpServers = mcpServers;
     }
     getUserMemory() {
+        if (this.experimentalJitContext && this.contextManager) {
+            return [
+                this.contextManager.getGlobalMemory(),
+                this.contextManager.getEnvironmentMemory(),
+            ]
+                .filter(Boolean)
+                .join('\n\n');
+        }
         return this.userMemory;
     }
     setUserMemory(newUserMemory) {
@@ -697,25 +864,31 @@ export class Config {
         return this.experimentalJitContext;
     }
     getGeminiMdFileCount() {
+        if (this.experimentalJitContext && this.contextManager) {
+            return this.contextManager.getLoadedPaths().size;
+        }
         return this.geminiMdFileCount;
     }
     setGeminiMdFileCount(count) {
         this.geminiMdFileCount = count;
     }
     getGeminiMdFilePaths() {
+        if (this.experimentalJitContext && this.contextManager) {
+            return Array.from(this.contextManager.getLoadedPaths());
+        }
         return this.geminiMdFilePaths;
     }
     setGeminiMdFilePaths(paths) {
         this.geminiMdFilePaths = paths;
     }
     getApprovalMode() {
-        return this.approvalMode;
+        return this.policyEngine.getApprovalMode();
     }
     setApprovalMode(mode) {
         if (!this.isTrustedFolder() && mode !== ApprovalMode.DEFAULT) {
             throw new Error('Cannot enable privileged approval modes in an untrusted folder.');
         }
-        this.approvalMode = mode;
+        this.policyEngine.setApprovalMode(mode);
     }
     isYoloModeDisabled() {
         return this.disableYoloMode || !this.isTrustedFolder();
@@ -753,6 +926,9 @@ export class Config {
     getTelemetryUseCollector() {
         return this.telemetrySettings.useCollector ?? false;
     }
+    getTelemetryUseCliAuth() {
+        return this.telemetrySettings.useCliAuth ?? false;
+    }
     getGeminiClient() {
         return this.geminiClient;
     }
@@ -866,12 +1042,18 @@ export class Config {
     getEnableExtensionReloading() {
         return this.enableExtensionReloading;
     }
-    isModelAvailabilityServiceEnabled() {
-        return this.enableModelAvailabilityService;
+    getDisableLLMCorrection() {
+        return this.disableLLMCorrection;
+    }
+    isAgentsEnabled() {
+        return this.enableAgents;
     }
     getNoBrowser() {
         return this.noBrowser;
     }
+    getAgentsSettings() {
+        return this.agents;
+    }
     isBrowserLaunchSuppressed() {
         return this.getNoBrowser() || !shouldAttemptBrowserLaunch();
     }
@@ -892,21 +1074,12 @@ export class Config {
      * 'false' for untrusted.
      */
     isTrustedFolder() {
-        // isWorkspaceTrusted in cli/src/config/trustedFolder.js returns undefined
-        // when the file based trust value is unavailable, since it is mainly used
-        // in the initialization for trust dialogs, etc. Here we return true since
-        // config.isTrustedFolder() is used for the main business logic of blocking
-        // tool calls etc in the rest of the application.
-        //
-        // Default value is true since we load with trusted settings to avoid
-        // restarts in the more common path. If the user chooses to mark the folder
-        // as untrusted, the CLI will restart and we will have the trust value
-        // reloaded.
         const context = ideContextStore.get();
         if (context?.workspaceState?.isTrusted !== undefined) {
             return context.workspaceState.isTrusted;
         }
-        return this.trustedFolder ?? true;
+        // Default to untrusted if folder trust is enabled and no explicit value is set.
+        return this.folderTrust ? (this.trustedFolder ?? false) : true;
     }
     setIdeMode(value) {
         this.ideMode = value;
@@ -965,6 +1138,40 @@ export class Config {
             this.ptyInfo !== 'child_process' &&
             this.enableInteractiveShell);
     }
+    isSkillsSupportEnabled() {
+        return this.skillsSupport;
+    }
+    /**
+     * Reloads skills by re-discovering them from extensions and local directories.
+     */
+    async reloadSkills() {
+        if (!this.skillsSupport) {
+            return;
+        }
+        if (this.onReload) {
+            const refreshed = await this.onReload();
+            this.disabledSkills = refreshed.disabledSkills ?? [];
+            this.getSkillManager().setAdminSettings(refreshed.adminSkillsEnabled ?? this.adminSkillsEnabled);
+        }
+        if (this.getSkillManager().isAdminEnabled()) {
+            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().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();
+    }
     isInteractive() {
         return this.interactive;
     }
@@ -998,6 +1205,8 @@ export class Config {
             terminalHeight: config.terminalHeight ?? this.shellExecutionConfig.terminalHeight,
             showColor: config.showColor ?? this.shellExecutionConfig.showColor,
             pager: config.pager ?? this.shellExecutionConfig.pager,
+            sanitizationConfig: config.sanitizationConfig ??
+                this.shellExecutionConfig.sanitizationConfig,
         };
     }
     getScreenReader() {
@@ -1018,9 +1227,6 @@ export class Config {
     getTruncateToolOutputLines() {
         return this.truncateToolOutputLines;
     }
-    getUseSmartEdit() {
-        return this.useSmartEdit;
-    }
     getUseWriteTodos() {
         return this.useWriteTodos;
     }
@@ -1045,21 +1251,20 @@ export class Config {
     getPolicyEngine() {
         return this.policyEngine;
     }
-    getEnableMessageBusIntegration() {
-        return this.enableMessageBusIntegration;
-    }
     getEnableHooks() {
         return this.enableHooks;
     }
+    getEnableHooksUI() {
+        return this.enableHooksUI;
+    }
     getCodebaseInvestigatorSettings() {
         return this.codebaseInvestigatorSettings;
     }
+    getCliHelpAgentSettings() {
+        return this.cliHelpAgentSettings;
+    }
     async createToolRegistry() {
-        const registry = new ToolRegistry(this);
-        // Set message bus on tool registry before discovery so MCP tools can access it
-        if (this.getEnableMessageBusIntegration()) {
-            registry.setMessageBus(this.messageBus);
-        }
+        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) => {
@@ -1076,13 +1281,8 @@ export class Config {
                     tool.startsWith(`${normalizedClassName}(`));
             }
             if (isEnabled) {
-                // Pass message bus to tools when feature flag is enabled
-                // This first implementation is only focused on the general case of
-                // the tool registry.
-                const messageBusEnabled = this.getEnableMessageBusIntegration();
-                const toolArgs = messageBusEnabled
-                    ? [...args, this.getMessageBus()]
-                    : args;
+                // Pass message bus to tools (required for policy engine integration)
+                const toolArgs = [...args, this.getMessageBus()];
                 registry.registerTool(new ToolClass(...toolArgs));
             }
         };
@@ -1109,38 +1309,39 @@ export class Config {
             registerCoreTool(GrepTool, this);
         }
         registerCoreTool(GlobTool, this);
-        if (this.getUseSmartEdit()) {
-            registerCoreTool(SmartEditTool, this);
-        }
-        else {
-            registerCoreTool(EditTool, this);
-        }
+        registerCoreTool(ActivateSkillTool, this);
+        registerCoreTool(EditTool, this);
         registerCoreTool(WriteFileTool, this);
         registerCoreTool(WebFetchTool, this);
         registerCoreTool(ShellTool, this);
         registerCoreTool(MemoryTool);
         registerCoreTool(WebSearchTool, this);
         if (this.getUseWriteTodos()) {
-            registerCoreTool(WriteTodosTool, this);
+            registerCoreTool(WriteTodosTool);
         }
         // Register Subagents as Tools
-        if (this.getCodebaseInvestigatorSettings().enabled) {
-            const definition = this.agentRegistry.getDefinition('codebase_investigator');
-            if (definition) {
-                // We must respect the main allowed/exclude lists for agents too.
-                const allowedTools = this.getAllowedTools();
-                const isAllowed = !allowedTools || allowedTools.includes(definition.name);
-                if (isAllowed) {
-                    const messageBusEnabled = this.getEnableMessageBusIntegration();
-                    const wrapper = new SubagentToolWrapper(definition, this, messageBusEnabled ? this.getMessageBus() : undefined);
-                    registry.registerTool(wrapper);
-                }
-            }
-        }
+        // Register DelegateToAgentTool if agents are enabled
+        this.registerDelegateToAgentTool(registry);
         await registry.discoverAllTools();
         registry.sortTools();
         return registry;
     }
+    /**
+     * Registers the DelegateToAgentTool if agents or related features are enabled.
+     */
+    registerDelegateToAgentTool(registry) {
+        if (this.isAgentsEnabled() ||
+            this.getCodebaseInvestigatorSettings().enabled ||
+            this.getCliHelpAgentSettings().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);
+            }
+        }
+    }
     /**
      * Get the hook system instance
      */
@@ -1153,6 +1354,18 @@ export class Config {
     getHooks() {
         return this.hooks;
     }
+    /**
+     * Get project-specific hooks configuration
+     */
+    getProjectHooks() {
+        return this.projectHooks;
+    }
+    /**
+     * Get disabled hooks list
+     */
+    getDisabledHooks() {
+        return this.disabledHooks;
+    }
     /**
      * Get experiments configuration
      */
@@ -1203,6 +1416,31 @@ export class Config {
         });
         debugLogger.debug('Experiments loaded', summaryString);
     }
+    onAgentsRefreshed = async () => {
+        if (this.toolRegistry) {
+            this.registerDelegateToAgentTool(this.toolRegistry);
+        }
+        // Propagate updates to the active chat session
+        const client = this.getGeminiClient();
+        if (client?.isInitialized()) {
+            await client.setTools();
+            await client.updateSystemInstruction();
+        }
+        else {
+            debugLogger.debug('[Config] GeminiClient not initialized; skipping live prompt/tool refresh.');
+        }
+    };
+    /**
+     * Disposes of resources and removes event listeners.
+     */
+    async dispose() {
+        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 };