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

package/dist/src/config/settings.d.ts

@@ -3,8 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { type Settings, type MemoryImportFormat } from './settingsSchema.js';
-import type { ExtensionManager } from './extension-manager.js';
+import { type GeminiCodeAssistSetting } from '@google/gemini-cli-core';
+import { type Settings, type MemoryImportFormat, type SettingsSchema } from './settingsSchema.js';
 export type { Settings, MemoryImportFormat };
 export declare const USER_SETTINGS_PATH: string;
 export declare const USER_SETTINGS_DIR: string;
@@ -51,6 +51,7 @@ export interface SessionRetentionSettings {
 export interface SettingsError {
     message: string;
     path: string;
+    severity: 'error' | 'warning';
 }
 export interface SettingsFile {
     settings: Settings;
@@ -58,21 +59,22 @@ export interface SettingsFile {
     path: string;
     rawJson?: string;
 }
-export declare function needsMigration(settings: Record<string, unknown>): boolean;
-export declare function migrateSettingsToV1(v2Settings: Record<string, unknown>): Record<string, unknown>;
+export declare function getDefaultsFromSchema(schema?: SettingsSchema): Settings;
 export declare class LoadedSettings {
-    constructor(system: SettingsFile, systemDefaults: SettingsFile, user: SettingsFile, workspace: SettingsFile, isTrusted: boolean, migratedInMemoryScopes: Set<SettingScope>);
+    constructor(system: SettingsFile, systemDefaults: SettingsFile, user: SettingsFile, workspace: SettingsFile, isTrusted: boolean, errors?: SettingsError[]);
     readonly system: SettingsFile;
     readonly systemDefaults: SettingsFile;
     readonly user: SettingsFile;
     readonly workspace: SettingsFile;
     readonly isTrusted: boolean;
-    readonly migratedInMemoryScopes: Set<SettingScope>;
+    readonly errors: SettingsError[];
     private _merged;
+    private _remoteAdminSettings;
     get merged(): Settings;
     private computeMergedSettings;
     forScope(scope: LoadableSettingScope): SettingsFile;
     setValue(scope: LoadableSettingScope, key: string, value: unknown): void;
+    setRemoteAdminSettings(remoteSettings: GeminiCodeAssistSetting): void;
 }
 export declare function setUpCloudShellEnvironment(envFilePath: string | null): void;
 export declare function loadEnvironment(settings: Settings): void;
@@ -81,5 +83,5 @@ export declare function loadEnvironment(settings: Settings): void;
  * Project settings override user settings.
  */
 export declare function loadSettings(workspaceDir?: string): LoadedSettings;
-export declare function migrateDeprecatedSettings(loadedSettings: LoadedSettings, extensionManager: ExtensionManager): void;
 export declare function saveSettings(settingsFile: SettingsFile): void;
+export declare function saveModelChange(loadedSettings: LoadedSettings, model: string): void;

package/dist/src/config/settings.js

@@ -5,11 +5,11 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { homedir, platform } from 'node:os';
+import { platform } from 'node:os';
 import * as dotenv from 'dotenv';
 import process from 'node:process';
 import * as os from 'node:os';
-import { debugLogger, FatalConfigError, CELL_DIR, getErrorMessage, Storage, coreEvents, AuthType, } from '@google/gemini-cli-core';
+import { FatalConfigError, CELL_DIR, getErrorMessage, Storage, coreEvents, AuthType, homedir, } from '@google/gemini-cli-core';
 import { loadYamlConfig } from '@machina.ai/config-yaml';
 import stripJsonComments from 'strip-json-comments';
 import { DefaultLight } from '../ui/themes/default-light.js';
@@ -19,14 +19,20 @@ import { getSettingsSchema, } from './settingsSchema.js';
 import { resolveEnvVarsInObject } from '../utils/envVarResolver.js';
 import { customDeepMerge } from '../utils/deepMerge.js';
 import { updateSettingsFilePreservingFormat } from '../utils/commentJson.js';
-import { SettingPaths } from './settingPaths.js';
+import { validateSettings, formatValidationError, } from './settings-validation.js';
 function getMergeStrategyForPath(path) {
     let current = undefined;
     let currentSchema = getSettingsSchema();
+    let parent = undefined;
     for (const key of path) {
         if (!currentSchema || !currentSchema[key]) {
+            // Key not found in schema - check if parent has additionalProperties
+            if (parent?.additionalProperties?.mergeStrategy) {
+                return parent.additionalProperties.mergeStrategy;
+            }
             return undefined;
         }
+        parent = current;
         current = currentSchema[key];
         currentSchema = current.properties;
     }
@@ -35,77 +41,6 @@ function getMergeStrategyForPath(path) {
 export const USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
 export const USER_SETTINGS_DIR = path.dirname(USER_SETTINGS_PATH);
 export const DEFAULT_EXCLUDED_ENV_VARS = ['DEBUG', 'DEBUG_MODE'];
-const MIGRATE_V2_OVERWRITE = true;
-const MIGRATION_MAP = {
-    accessibility: 'ui.accessibility',
-    allowedTools: 'tools.allowed',
-    allowMCPServers: 'mcp.allowed',
-    autoAccept: 'tools.autoAccept',
-    autoConfigureMaxOldSpaceSize: 'advanced.autoConfigureMemory',
-    bugCommand: 'advanced.bugCommand',
-    chatCompression: 'model.compressionThreshold',
-    checkpointing: 'general.checkpointing',
-    coreTools: 'tools.core',
-    contextFileName: 'context.fileName',
-    customThemes: 'ui.customThemes',
-    customWittyPhrases: 'ui.customWittyPhrases',
-    debugKeystrokeLogging: 'general.debugKeystrokeLogging',
-    disableAutoUpdate: 'general.disableAutoUpdate',
-    disableUpdateNag: 'general.disableUpdateNag',
-    dnsResolutionOrder: 'advanced.dnsResolutionOrder',
-    enableMessageBusIntegration: 'tools.enableMessageBusIntegration',
-    enableHooks: 'tools.enableHooks',
-    enablePromptCompletion: 'general.enablePromptCompletion',
-    enforcedAuthType: 'security.auth.enforcedType',
-    excludeTools: 'tools.exclude',
-    excludeMCPServers: 'mcp.excluded',
-    excludedProjectEnvVars: 'advanced.excludedEnvVars',
-    extensionManagement: 'experimental.extensionManagement',
-    extensions: 'extensions',
-    fileFiltering: 'context.fileFiltering',
-    folderTrustFeature: 'security.folderTrust.featureEnabled',
-    folderTrust: 'security.folderTrust.enabled',
-    hasSeenIdeIntegrationNudge: 'ide.hasSeenNudge',
-    hideWindowTitle: 'ui.hideWindowTitle',
-    showStatusInTitle: 'ui.showStatusInTitle',
-    hideTips: 'ui.hideTips',
-    hideBanner: 'ui.hideBanner',
-    hideFooter: 'ui.hideFooter',
-    hideCWD: 'ui.footer.hideCWD',
-    hideSandboxStatus: 'ui.footer.hideSandboxStatus',
-    hideModelInfo: 'ui.footer.hideModelInfo',
-    hideContextSummary: 'ui.hideContextSummary',
-    showMemoryUsage: 'ui.showMemoryUsage',
-    showLineNumbers: 'ui.showLineNumbers',
-    showCitations: 'ui.showCitations',
-    ideMode: 'ide.enabled',
-    includeDirectories: 'context.includeDirectories',
-    loadMemoryFromIncludeDirectories: 'context.loadFromIncludeDirectories',
-    maxSessionTurns: 'model.maxSessionTurns',
-    mcpServers: 'mcpServers',
-    mcpServerCommand: 'mcp.serverCommand',
-    memoryImportFormat: 'context.importFormat',
-    memoryDiscoveryMaxDirs: 'context.discoveryMaxDirs',
-    model: 'model.name',
-    preferredEditor: SettingPaths.General.PreferredEditor,
-    retryFetchErrors: 'general.retryFetchErrors',
-    sandbox: 'tools.sandbox',
-    selectedAuthType: 'security.auth.selectedType',
-    enableInteractiveShell: 'tools.shell.enableInteractiveShell',
-    shellPager: 'tools.shell.pager',
-    shellShowColor: 'tools.shell.showColor',
-    shellInactivityTimeout: 'tools.shell.inactivityTimeout',
-    skipNextSpeakerCheck: 'model.skipNextSpeakerCheck',
-    summarizeToolOutput: 'model.summarizeToolOutput',
-    telemetry: 'telemetry',
-    theme: 'ui.theme',
-    toolDiscoveryCommand: 'tools.discoveryCommand',
-    toolCallCommand: 'tools.callCommand',
-    usageStatisticsEnabled: 'privacy.usageStatisticsEnabled',
-    useExternalAuth: 'security.auth.useExternal',
-    useRipgrep: 'tools.useRipgrep',
-    vimMode: 'general.vimMode',
-};
 export function getSystemSettingsPath() {
     if (process.env['CELL_CLI_SYSTEM_SETTINGS_PATH']) {
         return process.env['CELL_CLI_SYSTEM_SETTINGS_PATH'];
@@ -173,126 +108,42 @@ function setNestedProperty(obj, path, value) {
     }
     current[lastKey] = value;
 }
-export function needsMigration(settings) {
-    // A file needs migration if it contains any top-level key that is moved to a
-    // nested location in V2.
-    const hasV1Keys = Object.entries(MIGRATION_MAP).some(([v1Key, v2Path]) => {
-        if (v1Key === v2Path || !(v1Key in settings)) {
-            return false;
-        }
-        // If a key exists that is both a V1 key and a V2 container (like 'model'),
-        // we need to check the type. If it's an object, it's a V2 container and not
-        // a V1 key that needs migration.
-        if (KNOWN_V2_CONTAINERS.has(v1Key) &&
-            typeof settings[v1Key] === 'object' &&
-            settings[v1Key] !== null) {
-            return false;
-        }
-        return true;
-    });
-    return hasV1Keys;
-}
-function migrateSettingsToV2(flatSettings) {
-    if (!needsMigration(flatSettings)) {
-        return null;
-    }
-    const v2Settings = {};
-    const flatKeys = new Set(Object.keys(flatSettings));
-    for (const [oldKey, newPath] of Object.entries(MIGRATION_MAP)) {
-        if (flatKeys.has(oldKey)) {
-            setNestedProperty(v2Settings, newPath, flatSettings[oldKey]);
-            flatKeys.delete(oldKey);
-        }
-    }
-    // Preserve mcpServers at the top level
-    if (flatSettings['mcpServers']) {
-        v2Settings['mcpServers'] = flatSettings['mcpServers'];
-        flatKeys.delete('mcpServers');
-    }
-    // Carry over any unrecognized keys
-    for (const remainingKey of flatKeys) {
-        const existingValue = v2Settings[remainingKey];
-        const newValue = flatSettings[remainingKey];
-        if (typeof existingValue === 'object' &&
-            existingValue !== null &&
-            !Array.isArray(existingValue) &&
-            typeof newValue === 'object' &&
-            newValue !== null &&
-            !Array.isArray(newValue)) {
-            const pathAwareGetStrategy = (path) => getMergeStrategyForPath([remainingKey, ...path]);
-            v2Settings[remainingKey] = customDeepMerge(pathAwareGetStrategy, {}, newValue, existingValue);
-        }
-        else {
-            v2Settings[remainingKey] = newValue;
+export function getDefaultsFromSchema(schema = getSettingsSchema()) {
+    const defaults = {};
+    for (const key in schema) {
+        const definition = schema[key];
+        if (definition.properties) {
+            const childDefaults = getDefaultsFromSchema(definition.properties);
+            if (Object.keys(childDefaults).length > 0) {
+                defaults[key] = childDefaults;
+            }
         }
-    }
-    return v2Settings;
-}
-function getNestedProperty(obj, path) {
-    const keys = path.split('.');
-    let current = obj;
-    for (const key of keys) {
-        if (typeof current !== 'object' || current === null || !(key in current)) {
-            return undefined;
+        else if (definition.default !== undefined) {
+            defaults[key] = definition.default;
         }
-        current = current[key];
     }
-    return current;
-}
-const REVERSE_MIGRATION_MAP = Object.fromEntries(Object.entries(MIGRATION_MAP).map(([key, value]) => [value, key]));
-// Dynamically determine the top-level keys from the V2 settings structure.
-const KNOWN_V2_CONTAINERS = new Set(Object.values(MIGRATION_MAP).map((path) => path.split('.')[0]));
-export function migrateSettingsToV1(v2Settings) {
-    const v1Settings = {};
-    const v2Keys = new Set(Object.keys(v2Settings));
-    for (const [newPath, oldKey] of Object.entries(REVERSE_MIGRATION_MAP)) {
-        const value = getNestedProperty(v2Settings, newPath);
-        if (value !== undefined) {
-            v1Settings[oldKey] = value;
-            v2Keys.delete(newPath.split('.')[0]);
-        }
-    }
-    // Preserve mcpServers at the top level
-    if (v2Settings['mcpServers']) {
-        v1Settings['mcpServers'] = v2Settings['mcpServers'];
-        v2Keys.delete('mcpServers');
-    }
-    // Carry over any unrecognized keys
-    for (const remainingKey of v2Keys) {
-        const value = v2Settings[remainingKey];
-        if (value === undefined) {
-            continue;
-        }
-        // Don't carry over empty objects that were just containers for migrated settings.
-        if (KNOWN_V2_CONTAINERS.has(remainingKey) &&
-            typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            Object.keys(value).length === 0) {
-            continue;
-        }
-        v1Settings[remainingKey] = value;
-    }
-    return v1Settings;
+    return defaults;
 }
 function mergeSettings(system, systemDefaults, user, workspace, isTrusted) {
     const safeWorkspace = isTrusted ? workspace : {};
+    const schemaDefaults = getDefaultsFromSchema();
     // Settings are merged with the following precedence (last one wins for
     // single values):
-    // 1. System Defaults
-    // 2. User Settings
-    // 3. Workspace Settings
-    // 4. System Settings (as overrides)
-    return customDeepMerge(getMergeStrategyForPath, {}, systemDefaults, user, safeWorkspace, system);
+    // 1. Schema Defaults (Built-in)
+    // 2. System Defaults
+    // 3. User Settings
+    // 4. Workspace Settings
+    // 5. System Settings (as overrides)
+    return customDeepMerge(getMergeStrategyForPath, schemaDefaults, systemDefaults, user, safeWorkspace, system);
 }
 export class LoadedSettings {
-    constructor(system, systemDefaults, user, workspace, isTrusted, migratedInMemoryScopes) {
+    constructor(system, systemDefaults, user, workspace, isTrusted, errors = []) {
         this.system = system;
         this.systemDefaults = systemDefaults;
         this.user = user;
         this.workspace = workspace;
         this.isTrusted = isTrusted;
-        this.migratedInMemoryScopes = migratedInMemoryScopes;
+        this.errors = errors;
         this._merged = this.computeMergedSettings();
     }
     system;
@@ -300,13 +151,25 @@ export class LoadedSettings {
     user;
     workspace;
     isTrusted;
-    migratedInMemoryScopes;
+    errors;
     _merged;
+    _remoteAdminSettings;
     get merged() {
         return this._merged;
     }
     computeMergedSettings() {
-        return mergeSettings(this.system.settings, this.systemDefaults.settings, this.user.settings, this.workspace.settings, this.isTrusted);
+        const merged = mergeSettings(this.system.settings, this.systemDefaults.settings, this.user.settings, this.workspace.settings, this.isTrusted);
+        // Remote admin settings always take precedence and file-based admin settings
+        // are ignored.
+        const adminSettingSchema = getSettingsSchema().admin;
+        if (adminSettingSchema?.properties) {
+            const adminSchema = adminSettingSchema.properties;
+            const adminDefaults = getDefaultsFromSchema(adminSchema);
+            // The final admin settings are the defaults overridden by remote settings.
+            // Any admin settings from files are ignored.
+            merged.admin = customDeepMerge((path) => getMergeStrategyForPath(['admin', ...path]), adminDefaults, this._remoteAdminSettings?.admin ?? {});
+        }
+        return merged;
     }
     forScope(scope) {
         switch (scope) {
@@ -328,6 +191,23 @@ export class LoadedSettings {
         setNestedProperty(settingsFile.originalSettings, key, value);
         this._merged = this.computeMergedSettings();
         saveSettings(settingsFile);
+        coreEvents.emitSettingsChanged();
+    }
+    setRemoteAdminSettings(remoteSettings) {
+        const admin = {};
+        const { secureModeEnabled, mcpSetting, cliFeatureSetting } = remoteSettings;
+        if (secureModeEnabled !== undefined) {
+            admin.secureModeEnabled = secureModeEnabled;
+        }
+        if (mcpSetting?.mcpEnabled !== undefined) {
+            admin.mcp = { enabled: mcpSetting.mcpEnabled };
+        }
+        const extensionsSetting = cliFeatureSetting?.extensionsSetting;
+        if (extensionsSetting?.extensionsEnabled !== undefined) {
+            admin.extensions = { enabled: extensionsSetting.extensionsEnabled };
+        }
+        this._remoteAdminSettings = { admin };
+        this._merged = this.computeMergedSettings();
     }
 }
 function findEnvFile(startDir) {
@@ -428,7 +308,6 @@ export function loadSettings(workspaceDir = process.cwd()) {
     const settingsErrors = [];
     const systemSettingsPath = getSystemSettingsPath();
     const systemDefaultsPath = getSystemDefaultsPath();
-    const migratedInMemoryScopes = new Set();
     // Resolve paths to their canonical representation to handle symlinks
     const resolvedWorkspaceDir = path.resolve(workspaceDir);
     const resolvedHomeDir = path.resolve(homedir());
@@ -454,6 +333,7 @@ export function loadSettings(workspaceDir = process.cwd()) {
         settingsErrors.push({
             message: getErrorMessage(error),
             path: systemSettingsPath,
+            severity: 'error',
         });
     }
     // Load user settings
@@ -467,6 +347,7 @@ export function loadSettings(workspaceDir = process.cwd()) {
         settingsErrors.push({
             message: getErrorMessage(error),
             path: USER_SETTINGS_PATH,
+            severity: 'error',
         });
     }
     // --- MCP Server Configuration Logic with Fallback ---
@@ -482,14 +363,14 @@ export function loadSettings(workspaceDir = process.cwd()) {
             }
         }
     }
-    catch (e) {
-        debugLogger.log('Could not read MCP server state file for fallback check:', e);
+    catch (_e) {
+        // Ignore error reading state file
     }
     if (hasFailedTooManyTimes) {
-        console.warn("[WARNING] The managed 'cell' server has failed to install multiple times.");
+        coreEvents.emitFeedback('warning', "[WARNING] The managed 'cell' server has failed to install multiple times.");
         const backupCell = userSettings.backupSettings?.['Cell'];
         if (backupCell) {
-            console.warn("[WARNING] Restoring your previous manual configuration as 'Cell'.");
+            coreEvents.emitFeedback('warning', "[WARNING] Restoring your previous manual configuration as 'Cell'.");
             if (!userSettings.mcpServers) {
                 userSettings.mcpServers = {};
             }
@@ -562,7 +443,45 @@ export function loadSettings(workspaceDir = process.cwd()) {
             originalSettings: userSettings,
         });
     }
-    const loadAndMigrate = (filePath, scope) => {
+    const migrateLegacySettings = (settings) => {
+        // Migrate includeDirectories -> context.includeDirectories
+        if (Array.isArray(settings['includeDirectories'])) {
+            if (!settings['context']) {
+                settings['context'] = {};
+            }
+            const context = settings['context'];
+            if (!Array.isArray(context['includeDirectories'])) {
+                context['includeDirectories'] = [];
+            }
+            context['includeDirectories'].push(...settings['includeDirectories']);
+            delete settings['includeDirectories'];
+        }
+        // Migrate excludeTools -> tools.exclude
+        if (Array.isArray(settings['excludeTools'])) {
+            if (!settings['tools']) {
+                settings['tools'] = {};
+            }
+            const tools = settings['tools'];
+            if (!Array.isArray(tools['exclude'])) {
+                tools['exclude'] = [];
+            }
+            tools['exclude'].push(...settings['excludeTools']);
+            delete settings['excludeTools'];
+        }
+        // Migrate excludedProjectEnvVars -> advanced.excludedEnvVars
+        if (Array.isArray(settings['excludedProjectEnvVars'])) {
+            if (!settings['advanced']) {
+                settings['advanced'] = {};
+            }
+            const advanced = settings['advanced'];
+            if (!Array.isArray(advanced['excludedEnvVars'])) {
+                advanced['excludedEnvVars'] = [];
+            }
+            advanced['excludedEnvVars'].push(...settings['excludedProjectEnvVars']);
+            delete settings['excludedProjectEnvVars'];
+        }
+    };
+    const load = (filePath) => {
         try {
             if (fs.existsSync(filePath)) {
                 const content = fs.readFileSync(filePath, 'utf-8');
@@ -573,27 +492,22 @@ export function loadSettings(workspaceDir = process.cwd()) {
                     settingsErrors.push({
                         message: 'Settings file is not a valid JSON object.',
                         path: filePath,
+                        severity: 'error',
                     });
                     return { settings: {} };
                 }
-                let settingsObject = rawSettings;
-                if (needsMigration(settingsObject)) {
-                    const migratedSettings = migrateSettingsToV2(settingsObject);
-                    if (migratedSettings) {
-                        if (MIGRATE_V2_OVERWRITE) {
-                            try {
-                                fs.renameSync(filePath, `${filePath}.orig`);
-                                fs.writeFileSync(filePath, JSON.stringify(migratedSettings, null, 2), 'utf-8');
-                            }
-                            catch (e) {
-                                coreEvents.emitFeedback('error', 'Failed to migrate settings file.', e);
-                            }
-                        }
-                        else {
-                            migratedInMemoryScopes.add(scope);
-                        }
-                        settingsObject = migratedSettings;
-                    }
+                const settingsObject = rawSettings;
+                // Migrate legacy settings before validation
+                migrateLegacySettings(settingsObject);
+                // Validate settings structure with Zod
+                const validationResult = validateSettings(settingsObject);
+                if (!validationResult.success && validationResult.error) {
+                    const errorMessage = formatValidationError(validationResult.error, filePath);
+                    settingsErrors.push({
+                        message: errorMessage,
+                        path: filePath,
+                        severity: 'warning',
+                    });
                 }
                 return { settings: settingsObject, rawJson: content };
             }
@@ -602,19 +516,20 @@ export function loadSettings(workspaceDir = process.cwd()) {
             settingsErrors.push({
                 message: getErrorMessage(error),
                 path: filePath,
+                severity: 'error',
             });
         }
         return { settings: {} };
     };
-    const systemResult = loadAndMigrate(systemSettingsPath, SettingScope.System);
-    const systemDefaultsResult = loadAndMigrate(systemDefaultsPath, SettingScope.SystemDefaults);
-    const userResult = loadAndMigrate(USER_SETTINGS_PATH, SettingScope.User);
+    const systemResult = load(systemSettingsPath);
+    const systemDefaultsResult = load(systemDefaultsPath);
+    const userResult = load(USER_SETTINGS_PATH);
     let workspaceResult = {
         settings: {},
         rawJson: undefined,
     };
     if (realWorkspaceDir !== realHomeDir) {
-        workspaceResult = loadAndMigrate(workspaceSettingsPath, SettingScope.Workspace);
+        workspaceResult = load(workspaceSettingsPath);
     }
     const systemOriginalSettings = structuredClone(systemResult.settings);
     const systemDefaultsOriginalSettings = structuredClone(systemDefaultsResult.settings);
@@ -657,9 +572,10 @@ export function loadSettings(workspaceDir = process.cwd()) {
     // loadEnvironment depends on settings so we have to create a temp version of
     // the settings to avoid a cycle
     loadEnvironment(tempMergedSettings);
-    // Create LoadedSettings first
-    if (settingsErrors.length > 0) {
-        const errorMessages = settingsErrors.map((error) => `Error in ${error.path}: ${error.message}`);
+    // Check for any fatal errors before proceeding
+    const fatalErrors = settingsErrors.filter((e) => e.severity === 'error');
+    if (fatalErrors.length > 0) {
+        const errorMessages = fatalErrors.map((error) => `Error in ${error.path}: ${error.message}`);
         throw new FatalConfigError(`${errorMessages.join('\n')}\nPlease fix the configuration file(s) and try again.`);
     }
     return new LoadedSettings({
@@ -682,23 +598,7 @@ export function loadSettings(workspaceDir = process.cwd()) {
         settings: workspaceSettings,
         originalSettings: workspaceOriginalSettings,
         rawJson: workspaceResult.rawJson,
-    }, isTrusted, migratedInMemoryScopes);
-}
-export function migrateDeprecatedSettings(loadedSettings, extensionManager) {
-    const processScope = (scope) => {
-        const settings = loadedSettings.forScope(scope).settings;
-        if (settings.extensions?.disabled) {
-            debugLogger.log(`Migrating deprecated extensions.disabled settings from ${scope} settings...`);
-            for (const extension of settings.extensions.disabled ?? []) {
-                extensionManager.disableExtension(extension, scope);
-            }
-            const newExtensionsValue = { ...settings.extensions };
-            newExtensionsValue.disabled = undefined;
-            loadedSettings.setValue(scope, 'extensions', newExtensionsValue);
-        }
-    };
-    processScope(SettingScope.User);
-    processScope(SettingScope.Workspace);
+    }, isTrusted, settingsErrors);
 }
 export function saveSettings(settingsFile) {
     try {
@@ -707,10 +607,7 @@ export function saveSettings(settingsFile) {
         if (!fs.existsSync(dirPath)) {
             fs.mkdirSync(dirPath, { recursive: true });
         }
-        let settingsToSave = settingsFile.originalSettings;
-        if (!MIGRATE_V2_OVERWRITE) {
-            settingsToSave = migrateSettingsToV1(settingsToSave);
-        }
+        const settingsToSave = settingsFile.originalSettings;
         // Use the format-preserving update function
         updateSettingsFilePreservingFormat(settingsFile.path, settingsToSave);
     }
@@ -718,4 +615,12 @@ export function saveSettings(settingsFile) {
         coreEvents.emitFeedback('error', 'There was an error saving your latest settings changes.', error);
     }
 }
+export function saveModelChange(loadedSettings, model) {
+    try {
+        loadedSettings.setValue(SettingScope.User, 'model.name', model);
+    }
+    catch (error) {
+        coreEvents.emitFeedback('error', 'There was an error saving your preferred model.', error);
+    }
+}
 //# sourceMappingURL=settings.js.map