@caupulican/pi-adaptative 0.81.26 → 0.81.29

package/dist/core/settings-manager.js

@@ -9,7 +9,7 @@ import { normalizePath, resolvePath } from "../utils/paths.js";
 import { DEFAULT_GOAL_AUTO_CONTINUE, DEFAULT_GOAL_AUTO_CONTINUE_DELAY_MS, DEFAULT_GOAL_CONTINUE_MAX_STALL_TURNS, DEFAULT_GOAL_CONTINUE_MAX_TURNS, DEFAULT_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, MAX_GOAL_AUTO_CONTINUE_DELAY_MS, MAX_GOAL_CONTINUE_MAX_STALL_TURNS, MAX_GOAL_CONTINUE_MAX_TURNS, MAX_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, } from "./goals/goal-continuation-defaults.js";
 import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
 import { ProfileRegistry } from "./profile-registry.js";
-import { mergeResourceProfileMap } from "./resource-profile-blocks.js";
+import { mergeResourceProfileMap, mergeResourceProfileSettings } from "./resource-profile-blocks.js";
 import { validateSkillName } from "./skills.js";
 export const MEMORY_RETRIEVAL_MAX_RESULTS_MIN = 1;
 export const MEMORY_RETRIEVAL_MAX_RESULTS_MAX = 20;
@@ -35,7 +35,7 @@ export const MAX_RESEARCH_LANE_MAX_FINDINGS = 50;
 export const MAX_RESEARCH_LANE_MAX_WALL_CLOCK_MS = 3_600_000;
 export const MAX_RESEARCH_LANE_IDLE_DELAY_MS = 300_000;
 export const MAX_RESEARCH_LANE_MAX_RUNS_PER_SESSION = 100;
-export const DEFAULT_WORKER_DELEGATION_ENABLED = false;
+export const DEFAULT_WORKER_DELEGATION_ENABLED = true;
 export const DEFAULT_WORKER_DELEGATION_MAX_USD = 0.5;
 export const DEFAULT_WORKER_DELEGATION_MAX_WALL_CLOCK_MS = 120_000;
 export const MAX_WORKER_DELEGATION_MAX_USD = 5;
@@ -144,9 +144,17 @@ function normalizeResourceProfileNames(value) {
 function hasExplicitActiveResourceProfileSelection(settings) {
     return Object.hasOwn(settings, "activeResourceProfiles") || Object.hasOwn(settings, "activeResourceProfile");
 }
+function hasExplicitEmptyActiveResourceProfileSelection(settings) {
+    return (Object.hasOwn(settings, "activeResourceProfiles") &&
+        normalizeResourceProfileNames(settings.activeResourceProfiles).length === 0);
+}
 function normalizeActiveResourceProfiles(settings) {
-    const explicitProfiles = normalizeResourceProfileNames(settings.activeResourceProfiles);
-    const values = explicitProfiles.length > 0 ? explicitProfiles : normalizeResourceProfileNames(settings.activeResourceProfile);
+    // The array form is canonical when present, including an explicit empty array. Falling through
+    // from `activeResourceProfiles: []` to the scalar alias would resurrect a lower-precedence or
+    // legacy selection and makes it impossible to persist a durable "none" choice.
+    const values = Object.hasOwn(settings, "activeResourceProfiles")
+        ? normalizeResourceProfileNames(settings.activeResourceProfiles)
+        : normalizeResourceProfileNames(settings.activeResourceProfile);
     if (values.length === 0 &&
         !hasExplicitActiveResourceProfileSelection(settings) &&
         settings.resourceProfiles?.default) {
@@ -205,7 +213,7 @@ function sanitizeNumberSetting(value, fallback, min, max) {
         return fallback;
     return value;
 }
-const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
 function isThinkingLevel(value) {
     return typeof value === "string" && VALID_THINKING_LEVELS.includes(value);
 }
@@ -275,12 +283,12 @@ function normalizeModelRouterSettings(value) {
     }
     return Object.keys(settings).length > 0 ? settings : undefined;
 }
-function parseProfileFileDefinition(content) {
+function parseProfileFileDefinition(content, fallbackName) {
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         throw new Error("profile file must contain a JSON object");
     }
-    const name = typeof parsed.name === "string" ? parsed.name.trim() : undefined;
+    const name = (typeof parsed.name === "string" ? parsed.name.trim() : undefined) || fallbackName;
     if (!name) {
         throw new Error("profile name is required");
     }
@@ -296,6 +304,7 @@ function parseProfileFileDefinition(content) {
     };
 }
 export class FileSettingsStorage {
+    profileResolutionBaseDir;
     globalSettingsPath;
     projectSettingsPath;
     directoryProfileInfo;
@@ -303,6 +312,7 @@ export class FileSettingsStorage {
     constructor(cwd, agentDir) {
         const resolvedCwd = resolvePath(cwd);
         const resolvedAgentDir = resolvePath(agentDir);
+        this.profileResolutionBaseDir = resolvedCwd;
         this.globalSettingsPath = join(resolvedAgentDir, "settings.json");
         this.projectSettingsPath = join(resolvedCwd, CONFIG_DIR_NAME, "settings.json");
         this.directoryProfileInfo = getDirectoryResourceProfileInfo(resolvedCwd, resolvedAgentDir);
@@ -314,6 +324,9 @@ export class FileSettingsStorage {
     getProfilesDir() {
         return this.profilesDir;
     }
+    getProfileResolutionBaseDir() {
+        return this.profileResolutionBaseDir;
+    }
     readDirectoryResourceProfile() {
         const path = this.directoryProfileInfo.path;
         return existsSync(path) ? readFileSync(path, "utf-8") : undefined;
@@ -454,9 +467,15 @@ export class SettingsManager {
         // Mirror getActiveResourceProfileNames()'s source precedence (runtime profiles from
         // --resource-profile take priority) so a bad runtime profile name still surfaces a
         // "profile not found" diagnostic instead of silently applying zero filtering.
-        if (this.runtimeResourceProfiles && this.runtimeResourceProfiles.length > 0) {
+        if (this.runtimeResourceProfiles !== undefined) {
             return normalizeResourceProfileNames(this.runtimeResourceProfiles);
         }
+        // `/profiles none` is persisted globally as an explicit empty array. It is a durable
+        // user-level off switch and must dominate project/directory/default/external fallbacks until
+        // the user explicitly selects another profile.
+        if (hasExplicitEmptyActiveResourceProfileSelection(this.globalSettings)) {
+            return [];
+        }
         const explicitProfiles = this.settings.activeResourceProfiles && this.settings.activeResourceProfiles.length > 0
             ? this.settings.activeResourceProfiles
             : this.settings.activeResourceProfile
@@ -492,16 +511,24 @@ export class SettingsManager {
             this.reportProfileDiagnostic("global", `Profile diagnostic${path}: ${diagnostic.message}`);
         }
         for (const profileName of this.getActiveProfileNamesForDiagnostics()) {
-            if (!this.profileRegistry.getProfile(profileName)) {
+            if (!this.resolveProfileFromRegistry(this.profileRegistry, profileName)) {
                 this.reportProfileDiagnostic("global", `Active profile not found: ${profileName}`);
             }
         }
     }
+    resolveProfileFromRegistry(registry, profileRef) {
+        return profileRef.startsWith("./") || profileRef.startsWith("../")
+            ? registry.resolveProfileRef(profileRef, this.storage.getProfileResolutionBaseDir?.() ?? process.cwd())
+            : registry.getProfile(profileRef);
+    }
     mergeEffectiveSettings() {
         let merged = deepMergeSettings(this.globalSettings, this.projectSettings);
         merged = deepMergeSettings(merged, this.directoryProfileSettings);
-        if (this.runtimeResourceProfiles) {
-            merged = deepMergeSettings(merged, { activeResourceProfiles: this.runtimeResourceProfiles });
+        if (this.runtimeResourceProfiles !== undefined) {
+            merged = deepMergeSettings(merged, {
+                activeResourceProfile: this.runtimeResourceProfiles,
+                activeResourceProfiles: this.runtimeResourceProfiles,
+            });
         }
         return merged;
     }
@@ -643,16 +670,22 @@ export class SettingsManager {
         return this.profileRegistry;
     }
     getActiveResourceProfileNames() {
-        if (this.runtimeResourceProfiles && this.runtimeResourceProfiles.length > 0) {
+        if (this.runtimeResourceProfiles !== undefined) {
             return [...this.runtimeResourceProfiles];
         }
+        if (hasExplicitEmptyActiveResourceProfileSelection(this.globalSettings)) {
+            return [];
+        }
         const names = normalizeActiveResourceProfiles(this.settings);
         return names.length > 0 || hasExplicitActiveResourceProfileSelection(this.settings)
             ? names
             : this.getExternalRootActiveResourceProfileNames();
     }
     hasExplicitActiveResourceProfileSelection() {
-        return hasExplicitActiveResourceProfileSelection(this.settings);
+        // An explicit empty runtime/settings selection means "no profile", not an invalid profile
+        // whose authority should collapse to deny-all. Non-empty unresolved refs remain explicit and
+        // are diagnosed/strictly denied through the normal active-profile path.
+        return this.getActiveResourceProfileNames().length > 0;
     }
     /**
      * Aggregate ONLY the active profiles' contribution to a resource kind's filter — the user's own
@@ -673,7 +706,7 @@ export class SettingsManager {
             if (seenProfiles.has(profileName))
                 continue;
             seenProfiles.add(profileName);
-            const kindFilter = registry.getProfile(profileName)?.resources[kind];
+            const kindFilter = this.resolveProfileFromRegistry(registry, profileName)?.resources[kind];
             if (kindFilter && ((kindFilter.allow?.length ?? 0) > 0 || (kindFilter.block?.length ?? 0) > 0)) {
                 kindMentionedByProfile = true;
             }
@@ -713,7 +746,7 @@ export class SettingsManager {
         const registry = this.getProfileRegistry();
         const conflicts = new Set();
         for (const profileName of this.getActiveResourceProfileNames()) {
-            const filter = registry.getProfile(profileName)?.resources[kind];
+            const filter = this.resolveProfileFromRegistry(registry, profileName)?.resources[kind];
             for (const allowEntry of filter?.allow ?? []) {
                 if (allowEntry === "*")
                     continue;
@@ -763,7 +796,7 @@ export class SettingsManager {
             if (seen.has(profileName))
                 continue;
             seen.add(profileName);
-            const soul = registry.getProfile(profileName)?.soul?.trim();
+            const soul = this.resolveProfileFromRegistry(registry, profileName)?.soul?.trim();
             if (soul)
                 return soul;
         }
@@ -827,18 +860,69 @@ export class SettingsManager {
         }
         this.recomputeSettings();
     }
+    /** Capture the complete in-memory settings generation before runtime reload mutates it. */
+    createReloadSnapshot() {
+        return {
+            globalSettings: structuredClone(this.globalSettings),
+            projectSettings: structuredClone(this.projectSettings),
+            directoryProfileSettings: structuredClone(this.directoryProfileSettings),
+            runtimeResourceProfiles: this.runtimeResourceProfiles === undefined ? undefined : [...this.runtimeResourceProfiles],
+            inlineResourceProfileDefinitions: structuredClone(this.inlineResourceProfileDefinitions),
+            discoveredResourceProfileDefinitions: structuredClone(this.discoveredResourceProfileDefinitions),
+            effectiveSettings: structuredClone(this.settings),
+            projectTrusted: this.projectTrusted,
+            modifiedFields: new Set(this.modifiedFields),
+            modifiedNestedFields: this.cloneModifiedNestedFields(this.modifiedNestedFields),
+            modifiedProjectFields: new Set(this.modifiedProjectFields),
+            modifiedProjectNestedFields: this.cloneModifiedNestedFields(this.modifiedProjectNestedFields),
+            globalSettingsLoadError: this.globalSettingsLoadError,
+            projectSettingsLoadError: this.projectSettingsLoadError,
+            directoryProfileInfo: this.directoryProfileInfo ? { ...this.directoryProfileInfo } : null,
+            errors: [...this.errors],
+        };
+    }
+    /** Restore a failed runtime reload without changing the on-disk settings generation. */
+    restoreReloadSnapshot(snapshot) {
+        this.globalSettings = structuredClone(snapshot.globalSettings);
+        this.projectSettings = structuredClone(snapshot.projectSettings);
+        this.directoryProfileSettings = structuredClone(snapshot.directoryProfileSettings);
+        this.runtimeResourceProfiles =
+            snapshot.runtimeResourceProfiles === undefined ? undefined : [...snapshot.runtimeResourceProfiles];
+        this.inlineResourceProfileDefinitions = structuredClone(snapshot.inlineResourceProfileDefinitions);
+        this.discoveredResourceProfileDefinitions = structuredClone(snapshot.discoveredResourceProfileDefinitions);
+        this.settings = structuredClone(snapshot.effectiveSettings);
+        this.projectTrusted = snapshot.projectTrusted;
+        this.modifiedFields = new Set(snapshot.modifiedFields);
+        this.modifiedNestedFields = this.cloneModifiedNestedFields(snapshot.modifiedNestedFields);
+        this.modifiedProjectFields = new Set(snapshot.modifiedProjectFields);
+        this.modifiedProjectNestedFields = this.cloneModifiedNestedFields(snapshot.modifiedProjectNestedFields);
+        this.globalSettingsLoadError = snapshot.globalSettingsLoadError;
+        this.projectSettingsLoadError = snapshot.projectSettingsLoadError;
+        this.directoryProfileInfo = snapshot.directoryProfileInfo ? { ...snapshot.directoryProfileInfo } : null;
+        this.errors = [...snapshot.errors];
+        this.refreshProfileRegistry();
+    }
     /** Apply additional overrides on top of current settings */
     applyOverrides(overrides) {
         this.settings = deepMergeSettings(this.settings, overrides);
     }
     /** Select runtime-only resource profiles, e.g. from CLI/subagent launch options. */
     setRuntimeResourceProfiles(profileNames) {
-        this.runtimeResourceProfiles = profileNames.length > 0 ? [...profileNames] : undefined;
+        this.runtimeResourceProfiles = normalizeResourceProfileNames(profileNames);
         this.recomputeSettings();
     }
     /** Add one-shot profile definitions from CLI/SDK/ephemeral agent launch input. Never writes to disk. */
     addInlineResourceProfileDefinitions(profiles) {
-        this.inlineResourceProfileDefinitions = mergeResourceProfileMap(this.inlineResourceProfileDefinitions, profiles);
+        const next = { ...this.inlineResourceProfileDefinitions };
+        for (const [name, input] of Object.entries(profiles)) {
+            const existing = next[name];
+            const definition = Object.hasOwn(input, "resources")
+                ? input
+                : { resources: input };
+            const resources = mergeResourceProfileSettings(existing?.resources, definition.resources);
+            next[name] = this.mergeProfileDefinition(name, definition, resources, existing);
+        }
+        this.inlineResourceProfileDefinitions = next;
         this.refreshProfileRegistry();
     }
     /** Replace profile definitions discovered inside loaded resource files. Never writes to disk. */
@@ -862,6 +946,13 @@ export class SettingsManager {
         }
         return trimmed;
     }
+    normalizeProfileSelection(profileName) {
+        const trimmed = profileName.trim();
+        if (trimmed.startsWith("./") || trimmed.startsWith("../")) {
+            return trimmed;
+        }
+        return this.normalizeProfileName(trimmed);
+    }
     sanitizeProfileResources(resources) {
         const result = {};
         for (const kind of ["extensions", "skills", "prompts", "themes", "agents", "tools"]) {
@@ -876,15 +967,94 @@ export class SettingsManager {
         }
         return result;
     }
+    decodeStoredProfileDefinition(name, stored) {
+        if (stored && Object.hasOwn(stored, "resources")) {
+            const definition = stored;
+            return { ...definition, name, resources: this.sanitizeProfileResources(definition.resources) };
+        }
+        return {
+            name,
+            resources: this.sanitizeProfileResources(stored ?? {}),
+        };
+    }
+    mergeProfileDefinition(name, definition, resources, existing) {
+        const previous = this.decodeStoredProfileDefinition(name, existing);
+        return {
+            ...previous,
+            name,
+            resources,
+            description: definition.description ?? previous.description,
+            model: definition.model ?? previous.model,
+            thinking: definition.thinking ?? previous.thinking,
+            modelRouter: definition.modelRouter ?? previous.modelRouter,
+            soul: definition.soul ?? previous.soul,
+        };
+    }
+    encodeStoredProfileDefinition(definition) {
+        const hasMetadata = Boolean(definition.description || definition.model || definition.thinking || definition.modelRouter || definition.soul);
+        if (hasMetadata)
+            return definition;
+        return Object.keys(definition.resources).length > 0 ? definition.resources : undefined;
+    }
     setActiveProfileInSettings(settings, profileName) {
         if (profileName) {
             settings.activeResourceProfile = profileName;
             settings.activeResourceProfiles = [profileName];
             return;
         }
-        delete settings.activeResourceProfiles;
+        settings.activeResourceProfiles = [];
         delete settings.activeResourceProfile;
     }
+    rewriteActiveProfileReference(settings, oldName, newName) {
+        let changed = false;
+        const rewrite = (values) => {
+            const next = values.flatMap((value) => {
+                if (value !== oldName)
+                    return [value];
+                changed = true;
+                return newName ? [newName] : [];
+            });
+            return [...new Set(next)];
+        };
+        if (settings.activeResourceProfiles !== undefined) {
+            const next = rewrite(normalizeResourceProfileNames(settings.activeResourceProfiles));
+            if (next.length > 0)
+                settings.activeResourceProfiles = next;
+            else
+                delete settings.activeResourceProfiles;
+        }
+        if (settings.activeResourceProfile !== undefined) {
+            const next = rewrite(normalizeResourceProfileNames(settings.activeResourceProfile));
+            if (next.length === 0)
+                delete settings.activeResourceProfile;
+            else
+                settings.activeResourceProfile =
+                    Array.isArray(settings.activeResourceProfile) || next.length > 1 ? next : next[0];
+        }
+        return changed;
+    }
+    rewriteReusableProfileSelections(oldName, newName) {
+        if (this.runtimeResourceProfiles?.includes(oldName)) {
+            this.runtimeResourceProfiles = [
+                ...new Set(this.runtimeResourceProfiles.flatMap((profile) => profile === oldName ? (newName ? [newName] : []) : [profile])),
+            ];
+        }
+        if (this.rewriteActiveProfileReference(this.globalSettings, oldName, newName)) {
+            this.markModified("activeResourceProfile");
+            this.markModified("activeResourceProfiles");
+            this.save();
+        }
+        const projectSettings = structuredClone(this.projectSettings);
+        if (this.rewriteActiveProfileReference(projectSettings, oldName, newName)) {
+            this.markProjectModified("activeResourceProfile");
+            this.markProjectModified("activeResourceProfiles");
+            this.saveProjectSettings(projectSettings);
+        }
+        if (this.rewriteActiveProfileReference(this.directoryProfileSettings, oldName, newName)) {
+            this.persistDirectoryProfiles(() => { });
+        }
+        this.recomputeSettings();
+    }
     persistDirectoryProfiles(update) {
         const next = structuredClone(this.directoryProfileSettings);
         update(next);
@@ -932,8 +1102,9 @@ export class SettingsManager {
         const resources = this.sanitizeProfileResources(definition.resources);
         if (scope === "session") {
             const next = { ...this.inlineResourceProfileDefinitions };
-            if (Object.keys(resources).length > 0) {
-                next[name] = resources;
+            const payload = this.mergeProfileDefinition(name, definition, resources, next[name]);
+            if (this.encodeStoredProfileDefinition(payload)) {
+                next[name] = payload;
             }
             else {
                 delete next[name];
@@ -945,8 +1116,9 @@ export class SettingsManager {
         if (scope === "global") {
             const next = structuredClone(this.globalSettings);
             next.resourceProfiles = { ...(next.resourceProfiles ?? {}) };
-            if (Object.keys(resources).length > 0) {
-                next.resourceProfiles[name] = resources;
+            const stored = this.encodeStoredProfileDefinition(this.mergeProfileDefinition(name, definition, resources, next.resourceProfiles[name]));
+            if (stored) {
+                next.resourceProfiles[name] = stored;
             }
             else {
                 delete next.resourceProfiles[name];
@@ -962,8 +1134,9 @@ export class SettingsManager {
         if (scope === "project") {
             this.updateProjectSettings("resourceProfiles", (settings) => {
                 const next = structuredClone(settings.resourceProfiles ?? {});
-                if (Object.keys(resources).length > 0) {
-                    next[name] = resources;
+                const stored = this.encodeStoredProfileDefinition(this.mergeProfileDefinition(name, definition, resources, next[name]));
+                if (stored) {
+                    next[name] = stored;
                 }
                 else {
                     delete next[name];
@@ -980,8 +1153,9 @@ export class SettingsManager {
         if (scope === "directory") {
             this.persistDirectoryProfiles((current) => {
                 const next = { ...(current.resourceProfiles ?? {}) };
-                if (Object.keys(resources).length > 0) {
-                    next[name] = resources;
+                const stored = this.encodeStoredProfileDefinition(this.mergeProfileDefinition(name, definition, resources, next[name]));
+                if (stored) {
+                    next[name] = stored;
                 }
                 else {
                     delete next[name];
@@ -997,17 +1171,9 @@ export class SettingsManager {
         }
         const path = this.getProfileFilePath(name);
         const existing = existsSync(path)
-            ? parseProfileFileDefinition(readFileSync(path, "utf-8"))
+            ? parseProfileFileDefinition(readFileSync(path, "utf-8"), name)
             : { name, resources: {} };
-        const payload = {
-            ...existing,
-            name,
-            resources,
-            description: definition.description ?? existing.description,
-            model: definition.model ?? existing.model,
-            thinking: definition.thinking ?? existing.thinking,
-            modelRouter: definition.modelRouter ?? existing.modelRouter,
-        };
+        const payload = this.mergeProfileDefinition(name, definition, resources, existing);
         mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, JSON.stringify(payload, null, 2), "utf-8");
     }
@@ -1097,6 +1263,7 @@ export class SettingsManager {
             throw new Error(`Profile not found: ${name}`);
         }
         rmSync(profilePath, { force: true });
+        this.rewriteReusableProfileSelections(name, undefined);
     }
     renameProfile(profileName, newProfileName, scope) {
         const oldName = this.normalizeProfileName(profileName);
@@ -1191,16 +1358,17 @@ export class SettingsManager {
         if (existsSync(newPath)) {
             throw new Error(`Profile already exists: ${newName}`);
         }
-        const parsed = parseProfileFileDefinition(readFileSync(oldPath, "utf-8"));
+        const parsed = parseProfileFileDefinition(readFileSync(oldPath, "utf-8"), oldName);
         parsed.name = newName;
         writeFileSync(newPath, JSON.stringify(parsed, null, 2), "utf-8");
         rmSync(oldPath, { force: true });
+        this.rewriteReusableProfileSelections(oldName, newName);
     }
     /**
      * Set active profile selection in the selected scope.
      */
     setActiveProfile(profileName, scope) {
-        const name = profileName ? this.normalizeProfileName(profileName) : undefined;
+        const name = profileName ? this.normalizeProfileSelection(profileName) : undefined;
         if (scope === "session") {
             if (name) {
                 this.setRuntimeResourceProfiles([name]);
@@ -1217,7 +1385,7 @@ export class SettingsManager {
             }
             else {
                 delete this.globalSettings.activeResourceProfile;
-                delete this.globalSettings.activeResourceProfiles;
+                this.globalSettings.activeResourceProfiles = [];
             }
             this.markModified("activeResourceProfile");
             this.markModified("activeResourceProfiles");
@@ -1234,6 +1402,67 @@ export class SettingsManager {
             this.setActiveProfileInSettings(current, name);
         });
     }
+    /** Atomically replace the global profile/authority fields used by config restore and rollback. */
+    replaceGlobalResourceProfileConfiguration(configuration) {
+        const next = structuredClone(this.globalSettings);
+        const replace = (key) => {
+            const value = configuration[key];
+            if (value === undefined) {
+                delete next[key];
+            }
+            else {
+                next[key] = structuredClone(value);
+            }
+            this.markModified(key);
+        };
+        replace("resourceProfiles");
+        replace("activeResourceProfile");
+        replace("activeResourceProfiles");
+        replace("externalResourceRoots");
+        replace("trustedResourceRoots");
+        this.globalSettings = next;
+        this.save();
+    }
+    /** Restore one profile definition's persistent owner after a post-doctor commit failure. */
+    restoreProfileDefinitionFromReloadSnapshot(profileName, scope, snapshot) {
+        const name = this.normalizeProfileName(profileName);
+        if (scope === "session") {
+            const previous = snapshot.inlineResourceProfileDefinitions[name];
+            if (previous)
+                this.inlineResourceProfileDefinitions[name] = structuredClone(previous);
+            else
+                delete this.inlineResourceProfileDefinitions[name];
+            this.refreshProfileRegistry();
+            return;
+        }
+        const restoreDefinition = (settings, previous) => {
+            const definitions = structuredClone(settings.resourceProfiles ?? {});
+            const oldDefinition = previous.resourceProfiles?.[name];
+            if (oldDefinition)
+                definitions[name] = structuredClone(oldDefinition);
+            else
+                delete definitions[name];
+            if (Object.keys(definitions).length > 0)
+                settings.resourceProfiles = definitions;
+            else
+                delete settings.resourceProfiles;
+        };
+        if (scope === "global") {
+            restoreDefinition(this.globalSettings, snapshot.globalSettings);
+            this.markModified("resourceProfiles");
+            this.save();
+            return;
+        }
+        if (scope === "project") {
+            this.updateProjectSettings("resourceProfiles", (settings) => {
+                restoreDefinition(settings, snapshot.projectSettings);
+            });
+            return;
+        }
+        this.persistDirectoryProfiles((settings) => {
+            restoreDefinition(settings, snapshot.directoryProfileSettings);
+        });
+    }
     /** Mark a global field as modified during this session */
     markModified(field, nestedKey) {
         this.modifiedFields.add(field);
@@ -1479,7 +1708,7 @@ export class SettingsManager {
     }
     /**
      * Proactive per-turn cost guard (#34). Default ON in WARN-only mode with a high anomaly-catching
-     * ceiling so an unusually expensive turn surfaces a visible footer notice without ever silently
+     * projection threshold so an unusually expensive turn surfaces a visible footer notice without silently
      * changing behavior. Set `maxTurnUsd: 0` to disable, or `action: "downgrade"` to also auto-reduce
      * reasoning effort over the ceiling.
      */
@@ -1496,14 +1725,19 @@ export class SettingsManager {
         const activeProfileNames = this.getActiveResourceProfileNames();
         if (activeProfileNames.length === 0)
             return undefined;
+        const registry = this.getProfileRegistry();
         const merged = {};
         for (let index = activeProfileNames.length - 1; index >= 0; index--) {
-            const profile = this.profileRegistry.getProfile(activeProfileNames[index]);
+            const profile = this.resolveProfileFromRegistry(registry, activeProfileNames[index]);
             const router = profile?.modelRouter;
             if (!router)
                 continue;
             if (router.enabled !== undefined)
                 merged.enabled = router.enabled;
+            if (router.judgeEnabled !== undefined)
+                merged.judgeEnabled = router.judgeEnabled;
+            if (router.fitnessGate !== undefined)
+                merged.fitnessGate = router.fitnessGate;
             if (router.cheapModel !== undefined)
                 merged.cheapModel = router.cheapModel;
             if (router.mediumModel !== undefined)
@@ -1512,6 +1746,20 @@ export class SettingsManager {
                 merged.expensiveModel = router.expensiveModel;
             if (router.learningModel !== undefined)
                 merged.learningModel = router.learningModel;
+            if (router.judgeModel !== undefined)
+                merged.judgeModel = router.judgeModel;
+            if (router.executorModel !== undefined)
+                merged.executorModel = router.executorModel;
+            if (router.cheapThinking !== undefined)
+                merged.cheapThinking = router.cheapThinking;
+            if (router.mediumThinking !== undefined)
+                merged.mediumThinking = router.mediumThinking;
+            if (router.expensiveThinking !== undefined)
+                merged.expensiveThinking = router.expensiveThinking;
+            if (router.executorThinking !== undefined)
+                merged.executorThinking = router.executorThinking;
+            if (router.judgeThinking !== undefined)
+                merged.judgeThinking = router.judgeThinking;
         }
         return Object.keys(merged).length > 0 ? merged : undefined;
     }
@@ -1527,8 +1775,6 @@ export class SettingsManager {
             fitnessGate: this.settings.modelRouter?.fitnessGate ?? false,
             judgeModel: this.settings.modelRouter?.judgeModel?.trim() || undefined,
             executorModel: this.settings.modelRouter?.executorModel?.trim() || undefined,
-            // Not yet profile-overridable (same as judgeModel/executorModel above): validated here so a
-            // corrupt/hand-edited value on disk never reaches the routed-turn swap in agent-session.ts.
             cheapThinking: isThinkingLevel(this.settings.modelRouter?.cheapThinking)
                 ? this.settings.modelRouter?.cheapThinking
                 : undefined,
@@ -1555,11 +1801,11 @@ export class SettingsManager {
             fitnessGate: profileSettings?.fitnessGate ?? settings.fitnessGate,
             judgeModel: profileSettings?.judgeModel?.trim() || settings.judgeModel,
             executorModel: profileSettings?.executorModel?.trim() || settings.executorModel,
-            cheapThinking: settings.cheapThinking,
-            mediumThinking: settings.mediumThinking,
-            expensiveThinking: settings.expensiveThinking,
-            executorThinking: settings.executorThinking,
-            judgeThinking: settings.judgeThinking,
+            cheapThinking: profileSettings?.cheapThinking ?? settings.cheapThinking,
+            mediumThinking: profileSettings?.mediumThinking ?? settings.mediumThinking,
+            expensiveThinking: profileSettings?.expensiveThinking ?? settings.expensiveThinking,
+            executorThinking: profileSettings?.executorThinking ?? settings.executorThinking,
+            judgeThinking: profileSettings?.judgeThinking ?? settings.judgeThinking,
         };
     }
     setModelRouterSettings(settings, scope = "global") {
@@ -1641,6 +1887,7 @@ export class SettingsManager {
                 "automata_graph_pointer_pack",
                 "learning_query_memory",
                 "subagent",
+                "delegate",
                 "task_steps",
                 "task_background",
                 "task_goal",
@@ -1710,9 +1957,10 @@ export class SettingsManager {
     }
     getMemoryRetrievalSettings() {
         return {
-            enabled: this.settings.contextPolicy?.memory?.enabled ?? false,
+            enabled: this.settings.contextPolicy?.memory?.enabled ?? true,
             maxResults: clampMemoryRetrievalMaxResults(this.settings.contextPolicy?.memory?.maxResults ?? MEMORY_RETRIEVAL_MAX_RESULTS_DEFAULT),
-            includeInPrompt: this.settings.contextPolicy?.memory?.includeInPrompt ?? false,
+            includeInPrompt: this.settings.contextPolicy?.memory?.includeInPrompt ?? true,
+            allowExternalEgress: this.settings.contextPolicy?.memory?.allowExternalEgress === true,
         };
     }
     setMemoryRetrievalSettings(settings, scope = "global") {
@@ -1720,6 +1968,7 @@ export class SettingsManager {
             enabled: settings.enabled,
             maxResults: settings.maxResults === undefined ? undefined : clampMemoryRetrievalMaxResults(settings.maxResults),
             includeInPrompt: settings.includeInPrompt,
+            allowExternalEgress: settings.allowExternalEgress,
         };
         if (scope === "project") {
             const projectSettings = structuredClone(this.projectSettings);