@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

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

@@ -10,7 +10,7 @@ vi.mock('os', async (importOriginal) => {
     const actualOs = await importOriginal();
     return {
         ...actualOs,
-        homedir: vi.fn(() => '/mock/home/user'),
+        homedir: vi.fn(() => path.resolve('/mock/home/user')),
         platform: vi.fn(() => 'linux'),
     };
 });
@@ -45,14 +45,16 @@ import stripJsonComments from 'strip-json-comments'; // Will be mocked separatel
 import { isWorkspaceTrusted } from './trustedFolders.js';
 // These imports will get the versions from the vi.mock('./settings.js', ...) factory.
 import { loadSettings, USER_SETTINGS_PATH, // This IS the mocked path.
-getSystemSettingsPath, getSystemDefaultsPath, saveSettings, getDefaultsFromSchema, loadEnvironment, migrateDeprecatedSettings, SettingScope, LoadedSettings, sanitizeEnvVar, } from './settings.js';
-import { FatalConfigError, CELL_DIR, AuthType, } from '@google/gemini-cli-core';
+getSystemSettingsPath, getSystemDefaultsPath, saveSettings, getDefaultsFromSchema, loadEnvironment, migrateDeprecatedSettings, SettingScope, LoadedSettings, sanitizeEnvVar, createTestMergedSettings, resetSettingsCacheForTesting, } from './settings.js';
+import { FatalConfigError, CELL_DIR, AuthType, Storage, } from '@google/gemini-cli-core';
 import { updateSettingsFilePreservingFormat } from '../utils/commentJson.js';
 import { getSettingsSchema, MergeStrategy, } from './settingsSchema.js';
 import { createMockSettings } from '../test-utils/settings.js';
-const MOCK_WORKSPACE_DIR = '/mock/workspace';
+const MOCK_WORKSPACE_DIR = path.resolve(path.resolve('/mock/workspace'));
 // Use the (mocked) CELL_DIR for consistency
 const MOCK_WORKSPACE_SETTINGS_PATH = path.join(MOCK_WORKSPACE_DIR, CELL_DIR, 'settings.json');
+// Helper to normalize paths for test assertions, making them OS-agnostic
+const normalizePath = (p) => path.normalize(p.toString());
 vi.mock('fs', async (importOriginal) => {
     // Get all the functions from the real 'fs' module
     const actualFs = await importOriginal();
@@ -74,6 +76,27 @@ const mockCoreEvents = vi.hoisted(() => ({
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const actual = await importOriginal();
     const os = await import('node:os');
+    const pathMod = await import('node:path');
+    const fsMod = await import('node:fs');
+    // Helper to resolve paths using the test's mocked environment
+    const testResolve = (p) => {
+        if (!p)
+            return '';
+        try {
+            // Use the mocked fs.realpathSync if available, otherwise fallback
+            return fsMod.realpathSync(pathMod.resolve(p));
+        }
+        catch {
+            return pathMod.resolve(p);
+        }
+    };
+    // Create a smarter mock for isWorkspaceHomeDir
+    vi.spyOn(actual.Storage.prototype, 'isWorkspaceHomeDir').mockImplementation(function () {
+        const target = testResolve(pathMod.dirname(this.getGeminiDir()));
+        // Pick up the mocked home directory specifically from the 'os' mock
+        const home = testResolve(os.homedir());
+        return actual.normalizePath(target) === actual.normalizePath(home);
+    });
     return {
         ...actual,
         coreEvents: mockCoreEvents,
@@ -98,10 +121,11 @@ describe('Settings Loading and Merging', () => {
     let mockFsMkdirSync;
     beforeEach(() => {
         vi.resetAllMocks();
+        resetSettingsCacheForTesting();
         mockFsExistsSync = vi.mocked(fs.existsSync);
         mockFsMkdirSync = vi.mocked(fs.mkdirSync);
         mockStripJsonComments = vi.mocked(stripJsonComments);
-        vi.mocked(osActual.homedir).mockReturnValue('/mock/home/user');
+        vi.mocked(osActual.homedir).mockReturnValue(path.resolve('/mock/home/user'));
         mockStripJsonComments.mockImplementation((jsonString) => jsonString);
         mockFsExistsSync.mockReturnValue(false);
         fs.readFileSync.mockReturnValue('{}'); // Return valid empty JSON
@@ -159,15 +183,15 @@ describe('Settings Loading and Merging', () => {
                     context: { fileName: 'WORKSPACE_CONTEXT.md' },
                 },
             },
-        ])('should load $scope settings if only $scope file exists', ({ scope, path, content }) => {
-            mockFsExistsSync.mockImplementation((p) => p === path);
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === path)
+        ])('should load $scope settings if only $scope file exists', ({ scope, path: p, content }) => {
+            mockFsExistsSync.mockImplementation((pathLike) => path.normalize(pathLike.toString()) === path.normalize(p));
+            fs.readFileSync.mockImplementation((pathDesc) => {
+                if (path.normalize(pathDesc.toString()) === path.normalize(p))
                     return JSON.stringify(content);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(path, 'utf-8');
+            expect(fs.readFileSync).toHaveBeenCalledWith(expect.stringContaining(path.basename(p)), 'utf-8');
             // Prepare expected object with default auth
             const expectedWithAuth = {
                 ...content,
@@ -188,9 +212,12 @@ describe('Settings Loading and Merging', () => {
             expect(settings.merged).toMatchObject(expectedWithAuth);
         });
         it('should merge system, user and workspace settings, with system taking precedence over workspace, and workspace over user', () => {
-            mockFsExistsSync.mockImplementation((p) => p === getSystemSettingsPath() ||
-                p === USER_SETTINGS_PATH ||
-                p === MOCK_WORKSPACE_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => {
+                const normP = path.normalize(p.toString());
+                return (normP === path.normalize(getSystemSettingsPath()) ||
+                    normP === path.normalize(USER_SETTINGS_PATH) ||
+                    normP === path.normalize(MOCK_WORKSPACE_SETTINGS_PATH));
+            });
             const systemSettingsContent = {
                 ui: {
                     theme: 'system-theme',
@@ -227,11 +254,12 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                const normP = path.normalize(p.toString());
+                if (normP === path.normalize(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normP === path.normalize(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normP === path.normalize(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '';
             });
@@ -363,13 +391,13 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemDefaultsPath())
+                if (normalizePath(p) === normalizePath(getSystemDefaultsPath()))
                     return JSON.stringify(systemDefaultsContent);
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '';
             });
@@ -428,11 +456,11 @@ describe('Settings Loading and Merging', () => {
             // No folderTrust here
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -463,11 +491,11 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -479,29 +507,33 @@ describe('Settings Loading and Merging', () => {
             const userSettingsContent = {
                 security: {
                     disableYoloMode: false,
+                    disableAlwaysAllow: false,
                 },
             };
             const workspaceSettingsContent = {
                 security: {
                     disableYoloMode: false, // This should be ignored
+                    disableAlwaysAllow: false, // This should be ignored
                 },
             };
             const systemSettingsContent = {
                 security: {
                     disableYoloMode: true,
+                    disableAlwaysAllow: true,
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.security?.disableYoloMode).toBe(true); // System setting should be used
+            expect(settings.merged.security?.disableAlwaysAllow).toBe(true); // System setting should be used
         });
         it.each([
             {
@@ -539,9 +571,9 @@ describe('Settings Loading and Merging', () => {
                 },
             },
         ])('should handle $description correctly', ({ path, content, expected }) => {
-            mockFsExistsSync.mockImplementation((p) => p === path);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(path));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === path)
+                if (normalizePath(p) === normalizePath(path))
                     return JSON.stringify(content);
                 return '{}';
             });
@@ -554,7 +586,8 @@ describe('Settings Loading and Merging', () => {
             expect(result).toEqual(expected.value);
         });
         it('should merge excludedProjectEnvVars with workspace taking precedence over user', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH || p === MOCK_WORKSPACE_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH) ||
+                normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH));
             const userSettingsContent = {
                 general: {},
                 advanced: { excludedEnvVars: ['DEBUG', 'NODE_ENV', 'USER_VAR'] },
@@ -564,9 +597,9 @@ describe('Settings Loading and Merging', () => {
                 advanced: { excludedEnvVars: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'] },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '';
             });
@@ -590,13 +623,14 @@ describe('Settings Loading and Merging', () => {
             ]);
         });
         it('should default contextFileName to undefined if not in any settings file', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH || p === MOCK_WORKSPACE_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH) ||
+                normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH));
             const userSettingsContent = { ui: { theme: 'dark' } };
             const workspaceSettingsContent = { tools: { sandbox: true } };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '';
             });
@@ -617,9 +651,9 @@ describe('Settings Loading and Merging', () => {
                 expected: false,
             },
         ])('should load telemetry setting from $scope settings', ({ path, content, expected }) => {
-            mockFsExistsSync.mockImplementation((p) => p === path);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(path));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === path)
+                if (normalizePath(p) === normalizePath(path))
                     return JSON.stringify(content);
                 return '{}';
             });
@@ -631,9 +665,9 @@ describe('Settings Loading and Merging', () => {
             const userSettingsContent = { telemetry: { enabled: true } };
             const workspaceSettingsContent = { telemetry: { enabled: false } };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -649,7 +683,8 @@ describe('Settings Loading and Merging', () => {
             expect(settings.merged.mcpServers).toEqual({});
         });
         it('should merge MCP servers correctly, with workspace taking precedence', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH || p === MOCK_WORKSPACE_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH) ||
+                normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH));
             const userSettingsContent = {
                 mcpServers: {
                     'user-server': {
@@ -677,9 +712,9 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '';
             });
@@ -748,9 +783,9 @@ describe('Settings Loading and Merging', () => {
                 },
             },
         ])('should handle MCP servers when only in $scope settings', ({ path, content, expected }) => {
-            mockFsExistsSync.mockImplementation((p) => p === path);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(path));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === path)
+                if (normalizePath(p) === normalizePath(path))
                     return JSON.stringify(content);
                 return '{}';
             });
@@ -799,11 +834,11 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -844,11 +879,11 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -887,9 +922,9 @@ describe('Settings Loading and Merging', () => {
             ])('$description', ({ userContent, workspaceContent, expected }) => {
                 mockFsExistsSync.mockReturnValue(true);
                 fs.readFileSync.mockImplementation((p) => {
-                    if (p === USER_SETTINGS_PATH)
+                    if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                         return JSON.stringify(userContent);
-                    if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                    if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                         return JSON.stringify(workspaceContent);
                     return '{}';
                 });
@@ -908,9 +943,9 @@ describe('Settings Loading and Merging', () => {
                 model: {},
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -932,13 +967,13 @@ describe('Settings Loading and Merging', () => {
                 context: { includeDirectories: ['/workspace/dir'] },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath()))
                     return JSON.stringify(systemSettingsContent);
-                if (p === getSystemDefaultsPath())
+                if (normalizePath(p) === normalizePath(getSystemDefaultsPath()))
                     return JSON.stringify(systemDefaultsContent);
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -957,14 +992,14 @@ describe('Settings Loading and Merging', () => {
             const userReadError = new SyntaxError("Expected ',' or '}' after property value in JSON at position 10");
             const workspaceReadError = new SyntaxError('Unexpected token i in JSON at position 0');
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH) {
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH)) {
                     // Simulate JSON.parse throwing for user settings
                     vi.spyOn(JSON, 'parse').mockImplementationOnce(() => {
                         throw userReadError;
                     });
                     return invalidJsonContent; // Content that would cause JSON.parse to throw
                 }
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH) {
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH)) {
                     // Simulate JSON.parse throwing for workspace settings
                     vi.spyOn(JSON, 'parse').mockImplementationOnce(() => {
                         throw workspaceReadError;
@@ -993,9 +1028,9 @@ describe('Settings Loading and Merging', () => {
                 apiKey: '$TEST_API_KEY',
                 someUrl: 'https://test.com/${TEST_API_KEY}',
             };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1011,9 +1046,9 @@ describe('Settings Loading and Merging', () => {
                 endpoint: '${WORKSPACE_ENDPOINT}/api',
                 nested: { value: '$WORKSPACE_ENDPOINT' },
             };
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1049,13 +1084,13 @@ describe('Settings Loading and Merging', () => {
             };
             mockFsExistsSync.mockReturnValue(true);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath())) {
                     return JSON.stringify(systemSettingsContent);
                 }
-                if (p === USER_SETTINGS_PATH) {
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH)) {
                     return JSON.stringify(userSettingsContent);
                 }
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH) {
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH)) {
                     return JSON.stringify(workspaceSettingsContent);
                 }
                 return '{}';
@@ -1088,9 +1123,9 @@ describe('Settings Loading and Merging', () => {
                 advanced: { dnsResolutionOrder: 'verbatim' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1098,12 +1133,12 @@ describe('Settings Loading and Merging', () => {
             expect(settings.merged.advanced?.dnsResolutionOrder).toBe('verbatim');
         });
         it('should use user dnsResolutionOrder if workspace is not defined', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             const userSettingsContent = {
                 advanced: { dnsResolutionOrder: 'verbatim' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1112,9 +1147,9 @@ describe('Settings Loading and Merging', () => {
         });
         it('should leave unresolved environment variables as is', () => {
             const userSettingsContent = { apiKey: '$UNDEFINED_VAR' };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1128,9 +1163,9 @@ describe('Settings Loading and Merging', () => {
             const userSettingsContent = {
                 path: '/path/$VAR_A/${VAR_B}/end',
             };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1145,9 +1180,9 @@ describe('Settings Loading and Merging', () => {
             const userSettingsContent = {
                 list: ['$ITEM_1', '${ITEM_2}', 'literal'],
             };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1177,9 +1212,9 @@ describe('Settings Loading and Merging', () => {
                     anotherEnv: '${MY_ENV_STRING_NESTED}',
                 },
             };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1205,9 +1240,9 @@ describe('Settings Loading and Merging', () => {
             const userSettingsContent = {
                 serverAddress: '${TEST_HOST}:${TEST_PORT}/api',
             };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1217,7 +1252,7 @@ describe('Settings Loading and Merging', () => {
             delete process.env['TEST_PORT'];
         });
         describe('when CELL_CLI_SYSTEM_SETTINGS_PATH is set', () => {
-            const MOCK_ENV_SYSTEM_SETTINGS_PATH = '/mock/env/system/settings.json';
+            const MOCK_ENV_SYSTEM_SETTINGS_PATH = path.resolve('/mock/env/system/settings.json');
             beforeEach(() => {
                 process.env['CELL_CLI_SYSTEM_SETTINGS_PATH'] =
                     MOCK_ENV_SYSTEM_SETTINGS_PATH;
@@ -1251,8 +1286,8 @@ describe('Settings Loading and Merging', () => {
             });
         });
         it('should correctly skip workspace-level loading if workspaceDir is a symlink to home', () => {
-            const mockHomeDir = '/mock/home/user';
-            const mockSymlinkDir = '/mock/symlink/to/home';
+            const mockHomeDir = path.resolve('/mock/home/user');
+            const mockSymlinkDir = path.resolve('/mock/symlink/to/home');
             const mockWorkspaceSettingsPath = path.join(mockSymlinkDir, CELL_DIR, 'settings.json');
             vi.mocked(osActual.homedir).mockReturnValue(mockHomeDir);
             vi.mocked(fs.realpathSync).mockImplementation((p) => {
@@ -1264,13 +1299,77 @@ describe('Settings Loading and Merging', () => {
                 }
                 return pStr;
             });
+            // Force the storage check to return true for this specific test
+            const isWorkspaceHomeDirSpy = vi
+                .spyOn(Storage.prototype, 'isWorkspaceHomeDir')
+                .mockReturnValue(true);
             mockFsExistsSync.mockImplementation((p) => 
             // Only return true for workspace settings path to see if it gets loaded
             p === mockWorkspaceSettingsPath);
-            const settings = loadSettings(mockSymlinkDir);
-            // Verify that even though the file exists, it was NOT loaded because realpath matched home
-            expect(fs.readFileSync).not.toHaveBeenCalledWith(mockWorkspaceSettingsPath, 'utf-8');
-            expect(settings.workspace.settings).toEqual({});
+            try {
+                const settings = loadSettings(mockSymlinkDir);
+                // Verify that even though the file exists, it was NOT loaded because realpath matched home
+                expect(fs.readFileSync).not.toHaveBeenCalledWith(mockWorkspaceSettingsPath, 'utf-8');
+                expect(settings.workspace.settings).toEqual({});
+            }
+            finally {
+                isWorkspaceHomeDirSpy.mockRestore();
+            }
+        });
+        describe('caching', () => {
+            it('should cache loadSettings results', () => {
+                const mockedRead = vi.mocked(fs.readFileSync);
+                mockedRead.mockClear();
+                mockedRead.mockReturnValue('{}');
+                mockFsExistsSync.mockReturnValue(true);
+                const settings1 = loadSettings(MOCK_WORKSPACE_DIR);
+                const settings2 = loadSettings(MOCK_WORKSPACE_DIR);
+                expect(mockedRead).toHaveBeenCalledTimes(8); // system, systemDefaults, user, workspace, env file, and MCP state/YAML
+                expect(settings1).toBe(settings2);
+            });
+            it('should use separate cache for different workspace directories', () => {
+                const mockedRead = vi.mocked(fs.readFileSync);
+                mockedRead.mockClear();
+                mockedRead.mockReturnValue('{}');
+                mockFsExistsSync.mockReturnValue(true);
+                const workspace1 = path.resolve('/mock/workspace1');
+                const workspace2 = path.resolve('/mock/workspace2');
+                const settings1 = loadSettings(workspace1);
+                const settings2 = loadSettings(workspace2);
+                expect(mockedRead).toHaveBeenCalledTimes(16); // 8 for each workspace
+                expect(settings1).not.toBe(settings2);
+            });
+            it('should clear cache when saveSettings is called for user settings', () => {
+                const mockedRead = vi.mocked(fs.readFileSync);
+                mockedRead.mockClear();
+                mockedRead.mockReturnValue('{}');
+                mockFsExistsSync.mockReturnValue(true);
+                const settings1 = loadSettings(MOCK_WORKSPACE_DIR);
+                expect(mockedRead).toHaveBeenCalledTimes(8);
+                saveSettings(settings1.user);
+                const settings2 = loadSettings(MOCK_WORKSPACE_DIR);
+                expect(mockedRead).toHaveBeenCalledTimes(16); // Should have re-read from disk
+                expect(settings1).not.toBe(settings2);
+            });
+            it('should clear all caches when saveSettings is called for workspace settings', () => {
+                const mockedRead = vi.mocked(fs.readFileSync);
+                mockedRead.mockClear();
+                mockedRead.mockReturnValue('{}');
+                mockFsExistsSync.mockReturnValue(true);
+                const workspace1 = path.resolve('/mock/workspace1');
+                const workspace2 = path.resolve('/mock/workspace2');
+                const settings1W1 = loadSettings(workspace1);
+                const settings1W2 = loadSettings(workspace2);
+                expect(mockedRead).toHaveBeenCalledTimes(16);
+                // Save settings for workspace 1
+                saveSettings(settings1W1.workspace);
+                const settings2W1 = loadSettings(workspace1);
+                const settings2W2 = loadSettings(workspace2);
+                // Both workspace caches should have been cleared and re-read from disk (+16 reads)
+                expect(mockedRead).toHaveBeenCalledTimes(32);
+                expect(settings1W1).not.toBe(settings2W1);
+                expect(settings1W2).not.toBe(settings2W2);
+            });
         });
     });
     describe('excludedProjectEnvVars integration', () => {
@@ -1287,23 +1386,23 @@ describe('Settings Loading and Merging', () => {
                 general: {},
                 advanced: { excludedEnvVars: ['DEBUG', 'DEBUG_MODE'] },
             };
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
             // Mock findEnvFile to return a project .env file
             const originalFindEnvFile = loadSettings.findEnvFile;
             loadSettings.findEnvFile =
-                () => '/mock/project/.env';
+                () => path.resolve('/mock/project/.env');
             // Mock fs.readFileSync for .env file content
             const originalReadFileSync = fs.readFileSync;
             fs.readFileSync.mockImplementation((p) => {
-                if (p === '/mock/project/.env') {
+                if (p === path.resolve('/mock/project/.env')) {
                     return 'DEBUG=true\nDEBUG_MODE=1\nGEMINI_API_KEY=test-key';
                 }
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH) {
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH)) {
                     return JSON.stringify(workspaceSettingsContent);
                 }
                 return '{}';
@@ -1331,9 +1430,9 @@ describe('Settings Loading and Merging', () => {
                 general: {},
                 advanced: { excludedEnvVars: ['NODE_ENV', 'DEBUG'] },
             };
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1359,9 +1458,9 @@ describe('Settings Loading and Merging', () => {
             };
             mockFsExistsSync.mockReturnValue(true);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1397,9 +1496,9 @@ describe('Settings Loading and Merging', () => {
                 context: { fileName: 'WORKSPACE.md' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1424,9 +1523,9 @@ describe('Settings Loading and Merging', () => {
                 context: { fileName: 'WORKSPACE.md' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1451,9 +1550,9 @@ describe('Settings Loading and Merging', () => {
                 context: { fileName: 'WORKSPACE.md' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1506,31 +1605,43 @@ describe('Settings Loading and Merging', () => {
             expect(process.env['TESTTEST']).toEqual('1234');
             expect(process.env['GEMINI_API_KEY']).toEqual('test-key');
         });
-        it('does not load env files from untrusted spaces', () => {
+        it('does not load env files from untrusted spaces when sandboxed', () => {
             setup({ isFolderTrustEnabled: true, isWorkspaceTrustedValue: false });
             const settings = {
                 security: { folderTrust: { enabled: true } },
+                tools: { sandbox: true },
             };
             loadEnvironment(settings, MOCK_WORKSPACE_DIR, isWorkspaceTrusted);
             expect(process.env['TESTTEST']).not.toEqual('1234');
         });
-        it('does not load env files when trust is undefined', () => {
+        it('does load env files from untrusted spaces when NOT sandboxed', () => {
+            setup({ isFolderTrustEnabled: true, isWorkspaceTrustedValue: false });
+            const settings = {
+                security: { folderTrust: { enabled: true } },
+                tools: { sandbox: false },
+            };
+            loadEnvironment(settings, MOCK_WORKSPACE_DIR, isWorkspaceTrusted);
+            expect(process.env['TESTTEST']).toEqual('1234');
+        });
+        it('does not load env files when trust is undefined and sandboxed', () => {
             delete process.env['TESTTEST'];
             // isWorkspaceTrusted returns {isTrusted: undefined} for matched rules with no trust value, or no matching rules.
             setup({ isFolderTrustEnabled: true, isWorkspaceTrustedValue: undefined });
             const settings = {
                 security: { folderTrust: { enabled: true } },
+                tools: { sandbox: true },
             };
             const mockTrustFn = vi.fn().mockReturnValue({ isTrusted: undefined });
             loadEnvironment(settings, MOCK_WORKSPACE_DIR, mockTrustFn);
             expect(process.env['TESTTEST']).not.toEqual('1234');
-            expect(process.env['GEMINI_API_KEY']).not.toEqual('test-key');
+            expect(process.env['GEMINI_API_KEY']).toEqual('test-key');
         });
         it('loads whitelisted env files from untrusted spaces if sandboxing is enabled', () => {
             setup({ isFolderTrustEnabled: true, isWorkspaceTrustedValue: false });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            settings.merged.tools.sandbox = true;
-            loadEnvironment(settings.merged, MOCK_WORKSPACE_DIR);
+            const settings = createTestMergedSettings({
+                tools: { sandbox: true },
+            });
+            loadEnvironment(settings, MOCK_WORKSPACE_DIR, isWorkspaceTrusted);
             // GEMINI_API_KEY is in the whitelist, so it should be loaded.
             expect(process.env['GEMINI_API_KEY']).toEqual('test-key');
             // TESTTEST is NOT in the whitelist, so it should be blocked.
@@ -1541,10 +1652,10 @@ describe('Settings Loading and Merging', () => {
             process.argv.push('-s');
             try {
                 setup({ isFolderTrustEnabled: true, isWorkspaceTrustedValue: false });
-                const settings = loadSettings(MOCK_WORKSPACE_DIR);
-                // Ensure sandbox is NOT in settings to test argv sniffing
-                settings.merged.tools.sandbox = undefined;
-                loadEnvironment(settings.merged, MOCK_WORKSPACE_DIR);
+                const settings = createTestMergedSettings({
+                    tools: { sandbox: false },
+                });
+                loadEnvironment(settings, MOCK_WORKSPACE_DIR, isWorkspaceTrusted);
                 expect(process.env['GEMINI_API_KEY']).toEqual('test-key');
                 expect(process.env['TESTTEST']).not.toEqual('1234');
             }
@@ -1580,9 +1691,9 @@ describe('Settings Loading and Merging', () => {
                 someOtherSetting: 'value',
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
                     return JSON.stringify(workspaceSettingsContent);
                 return '{}';
             });
@@ -1599,7 +1710,7 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1616,7 +1727,7 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1645,7 +1756,7 @@ describe('Settings Loading and Merging', () => {
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1665,8 +1776,66 @@ describe('Settings Loading and Merging', () => {
                     enableLoadingPhrases: false,
                 }),
             }));
+            // Check that enableLoadingPhrases: false was further migrated to loadingPhrases: 'off'
+            expect(setValueSpy).toHaveBeenCalledWith(SettingScope.User, 'ui', expect.objectContaining({
+                loadingPhrases: 'off',
+            }));
+        });
+        it('should migrate enableLoadingPhrases: false to loadingPhrases: off', () => {
+            const userSettingsContent = {
+                ui: {
+                    accessibility: {
+                        enableLoadingPhrases: false,
+                    },
+                },
+            };
+            const loadedSettings = createMockSettings(userSettingsContent);
+            const setValueSpy = vi.spyOn(loadedSettings, 'setValue');
+            migrateDeprecatedSettings(loadedSettings);
+            expect(setValueSpy).toHaveBeenCalledWith(SettingScope.User, 'ui', expect.objectContaining({
+                loadingPhrases: 'off',
+            }));
+        });
+        it('should not migrate enableLoadingPhrases: true to loadingPhrases', () => {
+            const userSettingsContent = {
+                ui: {
+                    accessibility: {
+                        enableLoadingPhrases: true,
+                    },
+                },
+            };
+            const loadedSettings = createMockSettings(userSettingsContent);
+            const setValueSpy = vi.spyOn(loadedSettings, 'setValue');
+            migrateDeprecatedSettings(loadedSettings);
+            // Should not set loadingPhrases when enableLoadingPhrases is true
+            const uiCalls = setValueSpy.mock.calls.filter((call) => call[1] === 'ui');
+            for (const call of uiCalls) {
+                const uiValue = call[2];
+                expect(uiValue).not.toHaveProperty('loadingPhrases');
+            }
+        });
+        it('should not overwrite existing loadingPhrases during migration', () => {
+            const userSettingsContent = {
+                ui: {
+                    loadingPhrases: 'witty',
+                    accessibility: {
+                        enableLoadingPhrases: false,
+                    },
+                },
+            };
+            const loadedSettings = createMockSettings(userSettingsContent);
+            const setValueSpy = vi.spyOn(loadedSettings, 'setValue');
+            migrateDeprecatedSettings(loadedSettings);
+            // Should not overwrite existing loadingPhrases
+            const uiCalls = setValueSpy.mock.calls.filter((call) => call[1] === 'ui');
+            for (const call of uiCalls) {
+                const uiValue = call[2];
+                if (uiValue['loadingPhrases'] !== undefined) {
+                    expect(uiValue['loadingPhrases']).toBe('witty');
+                }
+            }
         });
-        it('should prioritize new settings over deprecated ones and respect removeDeprecated flag', () => {
+        it('should remove deprecated settings by default and prioritize new ones', () => {
             const userSettingsContent = {
                 general: {
                     disableAutoUpdate: true,
@@ -1681,13 +1850,8 @@ describe('Settings Loading and Merging', () => {
             };
             const loadedSettings = createMockSettings(userSettingsContent);
             const setValueSpy = vi.spyOn(loadedSettings, 'setValue');
-            // 1. removeDeprecated = false (default)
+            // Default is now removeDeprecated = true
             migrateDeprecatedSettings(loadedSettings);
-            // Should still have old settings
-            expect(loadedSettings.forScope(SettingScope.User).settings.general).toHaveProperty('disableAutoUpdate');
-            expect(loadedSettings.forScope(SettingScope.User).settings.context.fileFiltering).toHaveProperty('disableFuzzySearch');
-            // 2. removeDeprecated = true
-            migrateDeprecatedSettings(loadedSettings, true);
             // Should remove disableAutoUpdate and trust enableAutoUpdate: true
             expect(setValueSpy).toHaveBeenCalledWith(SettingScope.User, 'general', {
                 enableAutoUpdate: true,
@@ -1697,15 +1861,34 @@ describe('Settings Loading and Merging', () => {
                 fileFiltering: { enableFuzzySearch: false },
             });
         });
+        it('should preserve deprecated settings when removeDeprecated is explicitly false', () => {
+            const userSettingsContent = {
+                general: {
+                    disableAutoUpdate: true,
+                    enableAutoUpdate: true,
+                },
+                context: {
+                    fileFiltering: {
+                        disableFuzzySearch: false,
+                        enableFuzzySearch: false,
+                    },
+                },
+            };
+            const loadedSettings = createMockSettings(userSettingsContent);
+            migrateDeprecatedSettings(loadedSettings, false);
+            // Should still have old settings since removeDeprecated = false
+            expect(loadedSettings.forScope(SettingScope.User).settings.general).toHaveProperty('disableAutoUpdate');
+            expect(loadedSettings.forScope(SettingScope.User).settings.context.fileFiltering).toHaveProperty('disableFuzzySearch');
+        });
         it('should trigger migration automatically during loadSettings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
             const userSettingsContent = {
                 general: {
                     disableAutoUpdate: true,
                 },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1730,10 +1913,10 @@ describe('Settings Loading and Merging', () => {
             };
             vi.mocked(fs.existsSync).mockReturnValue(true);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath())) {
                     return JSON.stringify(systemSettingsContent);
                 }
-                if (p === getSystemDefaultsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemDefaultsPath())) {
                     return JSON.stringify(systemDefaultsContent);
                 }
                 return '{}';
@@ -1765,7 +1948,7 @@ describe('Settings Loading and Merging', () => {
             };
             vi.mocked(fs.existsSync).mockReturnValue(true);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath())) {
                     return JSON.stringify(systemSettingsContent);
                 }
                 return '{}';
@@ -1800,7 +1983,7 @@ describe('Settings Loading and Merging', () => {
             };
             vi.mocked(fs.existsSync).mockReturnValue(true);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
                     return JSON.stringify(userSettingsContent);
                 return '{}';
             });
@@ -1832,9 +2015,9 @@ describe('Settings Loading and Merging', () => {
         it('should save settings using updateSettingsFilePreservingFormat', () => {
             const mockUpdateSettings = vi.mocked(updateSettingsFilePreservingFormat);
             const settingsFile = createMockSettings({ ui: { theme: 'dark' } }).user;
-            settingsFile.path = '/mock/settings.json';
+            settingsFile.path = path.resolve('/mock/settings.json');
             saveSettings(settingsFile);
-            expect(mockUpdateSettings).toHaveBeenCalledWith('/mock/settings.json', {
+            expect(mockUpdateSettings).toHaveBeenCalledWith(path.resolve('/mock/settings.json'), {
                 ui: { theme: 'dark' },
             });
         });
@@ -1843,10 +2026,10 @@ describe('Settings Loading and Merging', () => {
             const mockFsMkdirSync = vi.mocked(fs.mkdirSync);
             mockFsExistsSync.mockReturnValue(false);
             const settingsFile = createMockSettings({}).user;
-            settingsFile.path = '/mock/new/dir/settings.json';
+            settingsFile.path = path.resolve('/mock/new/dir/settings.json');
             saveSettings(settingsFile);
-            expect(mockFsExistsSync).toHaveBeenCalledWith('/mock/new/dir');
-            expect(mockFsMkdirSync).toHaveBeenCalledWith('/mock/new/dir', {
+            expect(mockFsExistsSync).toHaveBeenCalledWith(path.resolve('/mock/new/dir'));
+            expect(mockFsMkdirSync).toHaveBeenCalledWith(path.resolve('/mock/new/dir'), {
                 recursive: true,
             });
         });
@@ -1857,9 +2040,9 @@ describe('Settings Loading and Merging', () => {
                 throw error;
             });
             const settingsFile = createMockSettings({}).user;
-            settingsFile.path = '/mock/settings.json';
+            settingsFile.path = path.resolve('/mock/settings.json');
             saveSettings(settingsFile);
-            expect(mockCoreEvents.emitFeedback).toHaveBeenCalledWith('error', 'There was an error saving your latest settings changes.', error);
+            expect(mockCoreEvents.emitFeedback).toHaveBeenCalledWith('error', 'Failed to save settings: Write failed', error);
         });
     });
     describe('LoadedSettings and remote admin settings', () => {
@@ -1876,7 +2059,7 @@ describe('Settings Loading and Merging', () => {
                 ui: { theme: 'system-theme' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath())) {
                     return JSON.stringify(systemSettingsContent);
                 }
                 return '{}';
@@ -1915,7 +2098,7 @@ describe('Settings Loading and Merging', () => {
                 ui: { theme: 'initial-theme' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath())) {
                     return JSON.stringify(systemSettingsContent);
                 }
                 return '{}';
@@ -1948,7 +2131,7 @@ describe('Settings Loading and Merging', () => {
                 ui: { theme: 'initial-theme' },
             };
             fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath()) {
+                if (normalizePath(p) === normalizePath(getSystemSettingsPath())) {
                     return JSON.stringify(systemSettingsContent);
                 }
                 return '{}';
@@ -1983,6 +2166,23 @@ describe('Settings Loading and Merging', () => {
             });
             expect(loadedSettings.merged.admin?.mcp?.config).toEqual(mcpServers);
         });
+        it('should map requiredMcpConfig from remote settings', () => {
+            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
+            const requiredMcpConfig = {
+                'corp-tool': {
+                    url: 'https://mcp.corp/tool',
+                    type: 'http',
+                    trust: true,
+                },
+            };
+            loadedSettings.setRemoteAdminSettings({
+                mcpSetting: {
+                    mcpEnabled: true,
+                    requiredMcpConfig,
+                },
+            });
+            expect(loadedSettings.merged.admin?.mcp?.requiredConfig).toEqual(requiredMcpConfig);
+        });
         it('should set skills based on unmanagedCapabilitiesEnabled', () => {
             const loadedSettings = loadSettings();
             loadedSettings.setRemoteAdminSettings({
@@ -2043,6 +2243,34 @@ describe('Settings Loading and Merging', () => {
             });
         });
     });
+    describe('Reactivity & Snapshots', () => {
+        let loadedSettings;
+        beforeEach(() => {
+            const emptySettingsFile = {
+                path: path.resolve('/mock/path'),
+                settings: {},
+                originalSettings: {},
+            };
+            loadedSettings = new LoadedSettings({ ...emptySettingsFile, path: getSystemSettingsPath() }, { ...emptySettingsFile, path: getSystemDefaultsPath() }, { ...emptySettingsFile, path: USER_SETTINGS_PATH }, { ...emptySettingsFile, path: MOCK_WORKSPACE_SETTINGS_PATH }, true, // isTrusted
+            []);
+        });
+        it('getSnapshot() should return stable reference if no changes occur', () => {
+            const snap1 = loadedSettings.getSnapshot();
+            const snap2 = loadedSettings.getSnapshot();
+            expect(snap1).toBe(snap2);
+        });
+        it('setValue() should create a new snapshot reference and emit event', () => {
+            const oldSnapshot = loadedSettings.getSnapshot();
+            const oldUserRef = oldSnapshot.user.settings;
+            loadedSettings.setValue(SettingScope.User, 'ui.theme', 'high-contrast');
+            const newSnapshot = loadedSettings.getSnapshot();
+            expect(newSnapshot).not.toBe(oldSnapshot);
+            expect(newSnapshot.user.settings).not.toBe(oldUserRef);
+            expect(newSnapshot.user.settings.ui?.theme).toBe('high-contrast');
+            expect(newSnapshot.system.settings).not.toBe(oldSnapshot.system.settings);
+            expect(mockCoreEvents.emitSettingsChanged).toHaveBeenCalled();
+        });
+    });
     describe('Security and Sandbox', () => {
         let originalArgv;
         let originalEnv;
@@ -2098,7 +2326,7 @@ describe('Settings Loading and Merging', () => {
                 vi.mocked(fs.existsSync).mockImplementation((path) => path.toString().endsWith('.env'));
                 vi.mocked(fs.readFileSync).mockReturnValue('GEMINI_API_KEY=secret');
                 loadEnvironment(createMockSettings({ tools: { sandbox: false } }).merged, MOCK_WORKSPACE_DIR);
-                expect(process.env['GEMINI_API_KEY']).toBeUndefined();
+                expect(process.env['GEMINI_API_KEY']).toEqual('secret');
             });
             it('should NOT be tricked by positional arguments that look like flags', () => {
                 process.argv = ['node', 'gemini', 'my -s prompt'];
@@ -2109,7 +2337,7 @@ describe('Settings Loading and Merging', () => {
                 vi.mocked(fs.existsSync).mockImplementation((path) => path.toString().endsWith('.env'));
                 vi.mocked(fs.readFileSync).mockReturnValue('GEMINI_API_KEY=secret');
                 loadEnvironment(createMockSettings({ tools: { sandbox: false } }).merged, MOCK_WORKSPACE_DIR);
-                expect(process.env['GEMINI_API_KEY']).toBeUndefined();
+                expect(process.env['GEMINI_API_KEY']).toEqual('secret');
             });
         });
         describe('env var sanitization', () => {
@@ -2223,7 +2451,7 @@ describe('LoadedSettings Isolation and Serializability', () => {
         vi.resetAllMocks();
         // Create a minimal LoadedSettings instance
         const emptyScope = {
-            path: '/mock/settings.json',
+            path: path.resolve('/mock/settings.json'),
             settings: {},
             originalSettings: {},
         };