@caupulican/pi-adaptative 0.80.42 → 0.80.45

package/dist/core/settings-manager.js

@@ -1,12 +1,14 @@
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { minimatch } from "minimatch";
 import { basename, dirname, join, relative, resolve, sep } from "path";
 import lockfile from "proper-lockfile";
-import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
+import { CONFIG_DIR_NAME, getAgentDir, getProfilesDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.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 { validateSkillName } from "./skills.js";
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
 function deepMergeSettings(base, overrides) {
     const result = { ...base };
@@ -120,13 +122,6 @@ function collectLegacyDisabledFilterFromSettings(settings, kind) {
     const legacyDisabled = settings.disabledResources?.[kind];
     return Array.isArray(legacyDisabled) ? { block: legacyDisabled } : {};
 }
-function collectNamedResourceProfileFilters(settings, kind, profileNames) {
-    const result = {};
-    for (const profileName of profileNames) {
-        appendFilter(result, settings.resourceProfiles?.[profileName]?.[kind]);
-    }
-    return result;
-}
 function mergeResourceProfileFilters(...filters) {
     const result = {};
     for (const filter of filters)
@@ -143,20 +138,76 @@ function parseTimeoutSetting(value, settingName) {
     }
     return undefined;
 }
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+function isThinkingLevel(value) {
+    return typeof value === "string" && VALID_THINKING_LEVELS.includes(value);
+}
+function asStringArrayWithPattern(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const values = value.filter((item) => typeof item === "string" && item.trim().length > 0);
+    return values.length > 0 ? values : undefined;
+}
+function normalizeProfileFilterResource(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("resource profile filter must be an object");
+    }
+    const filter = value;
+    return {
+        allow: asStringArrayWithPattern(filter.allow),
+        block: asStringArrayWithPattern(filter.block),
+    };
+}
+function normalizeProfileResources(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("resources must be an object");
+    }
+    const input = value;
+    const result = {};
+    for (const kind of ["extensions", "skills", "prompts", "themes", "agents", "tools"]) {
+        if (input[kind] === undefined)
+            continue;
+        result[kind] = normalizeProfileFilterResource(input[kind]);
+    }
+    return result;
+}
+function parseProfileFileDefinition(content) {
+    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;
+    if (!name) {
+        throw new Error("profile name is required");
+    }
+    const resourceSection = parsed.resources ?? {};
+    return {
+        name,
+        description: typeof parsed.description === "string" ? parsed.description.trim() || undefined : undefined,
+        model: typeof parsed.model === "string" ? parsed.model.trim() || undefined : undefined,
+        thinking: isThinkingLevel(parsed.thinking) ? parsed.thinking : undefined,
+        resources: normalizeProfileResources(resourceSection),
+    };
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
     directoryProfileInfo;
+    profilesDir;
     constructor(cwd, agentDir) {
         const resolvedCwd = resolvePath(cwd);
         const resolvedAgentDir = resolvePath(agentDir);
         this.globalSettingsPath = join(resolvedAgentDir, "settings.json");
         this.projectSettingsPath = join(resolvedCwd, CONFIG_DIR_NAME, "settings.json");
         this.directoryProfileInfo = getDirectoryResourceProfileInfo(resolvedCwd, resolvedAgentDir);
+        this.profilesDir = getProfilesDir(resolvedAgentDir);
     }
     getDirectoryResourceProfileInfo() {
         return { ...this.directoryProfileInfo };
     }
+    getProfilesDir() {
+        return this.profilesDir;
+    }
     readDirectoryResourceProfile() {
         const path = this.directoryProfileInfo.path;
         return existsSync(path) ? readFileSync(path, "utf-8") : undefined;
@@ -186,7 +237,11 @@ export class FileSettingsStorage {
         throw lastError ?? new Error("Failed to acquire settings lock");
     }
     withLock(scope, fn) {
-        const path = scope === "global" ? this.globalSettingsPath : this.projectSettingsPath;
+        const path = scope === "global"
+            ? this.globalSettingsPath
+            : scope === "project"
+                ? this.projectSettingsPath
+                : this.directoryProfileInfo.path;
         const dir = dirname(path);
         let release;
         try {
@@ -218,17 +273,22 @@ export class FileSettingsStorage {
 export class InMemorySettingsStorage {
     global;
     project;
+    directoryProfile;
     withLock(scope, fn) {
-        const current = scope === "global" ? this.global : this.project;
+        const current = scope === "global" ? this.global : scope === "project" ? this.project : this.directoryProfile;
         const next = fn(current);
-        if (next !== undefined) {
-            if (scope === "global") {
-                this.global = next;
-            }
-            else {
-                this.project = next;
-            }
+        if (next === undefined) {
+            return;
+        }
+        if (scope === "global") {
+            this.global = next;
+            return;
+        }
+        if (scope === "project") {
+            this.project = next;
+            return;
         }
+        this.directoryProfile = next;
     }
 }
 export class SettingsManager {
@@ -248,6 +308,7 @@ export class SettingsManager {
     globalSettingsLoadError = null; // Track if global settings file had parse errors
     projectSettingsLoadError = null; // Track if project settings file had parse errors
     directoryProfileInfo = null;
+    profileRegistry;
     writeQueue = Promise.resolve();
     errors;
     constructor(storage, initialGlobal, initialProject, initialDirectoryProfile = {}, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true, directoryProfileInfo = null) {
@@ -261,6 +322,48 @@ export class SettingsManager {
         this.directoryProfileInfo = directoryProfileInfo;
         this.errors = [...initialErrors];
         this.settings = this.mergeEffectiveSettings();
+        this.refreshProfileRegistry();
+    }
+    createProfileRegistry() {
+        return new ProfileRegistry({
+            globalSettings: this.globalSettings,
+            projectSettings: this.projectSettings,
+            directoryProfileSettings: this.directoryProfileSettings,
+            inlineResourceProfileDefinitions: this.inlineResourceProfileDefinitions,
+            discoveredResourceProfileDefinitions: this.discoveredResourceProfileDefinitions,
+            profilesDir: this.storage.getProfilesDir?.(),
+        });
+    }
+    profileDiagnosticKeys = new Set();
+    reportProfileDiagnostic(scope, message) {
+        const key = `${scope}:${message}`;
+        if (this.profileDiagnosticKeys.has(key)) {
+            return;
+        }
+        this.profileDiagnosticKeys.add(key);
+        this.errors.push({ scope, error: new Error(message) });
+    }
+    getActiveProfileNamesForDiagnostics() {
+        const explicitProfiles = this.settings.activeResourceProfiles && this.settings.activeResourceProfiles.length > 0
+            ? this.settings.activeResourceProfiles
+            : this.settings.activeResourceProfile
+                ? [this.settings.activeResourceProfile]
+                : [];
+        return normalizeResourceProfileNames(explicitProfiles);
+    }
+    refreshProfileRegistry() {
+        this.profileDiagnosticKeys.clear();
+        this.profileRegistry = this.createProfileRegistry();
+        const registryDiagnostics = this.profileRegistry.listDiagnostics();
+        for (const diagnostic of registryDiagnostics) {
+            const path = diagnostic.path ? ` (${diagnostic.path})` : "";
+            this.reportProfileDiagnostic("global", `Profile diagnostic${path}: ${diagnostic.message}`);
+        }
+        for (const profileName of this.getActiveProfileNamesForDiagnostics()) {
+            if (!this.profileRegistry.getProfile(profileName)) {
+                this.reportProfileDiagnostic("global", `Active profile not found: ${profileName}`);
+            }
+        }
     }
     mergeEffectiveSettings() {
         let merged = deepMergeSettings(this.globalSettings, this.projectSettings);
@@ -272,6 +375,7 @@ export class SettingsManager {
     }
     recomputeSettings() {
         this.settings = this.mergeEffectiveSettings();
+        this.refreshProfileRegistry();
     }
     /** Create a SettingsManager that loads from files */
     static create(cwd, agentDir = getAgentDir(), options = {}) {
@@ -402,6 +506,10 @@ export class SettingsManager {
     getDirectoryResourceProfileInfo() {
         return this.directoryProfileInfo ? { ...this.directoryProfileInfo } : null;
     }
+    getProfileRegistry() {
+        this.refreshProfileRegistry();
+        return this.profileRegistry;
+    }
     getActiveResourceProfileNames() {
         if (this.runtimeResourceProfiles && this.runtimeResourceProfiles.length > 0) {
             return [...this.runtimeResourceProfiles];
@@ -410,8 +518,15 @@ export class SettingsManager {
     }
     getResourceProfileFilter(kind) {
         const legacyFilter = mergeResourceProfileFilters(collectLegacyDisabledFilterFromSettings(this.globalSettings, kind), collectLegacyDisabledFilterFromSettings(this.projectSettings, kind), collectLegacyDisabledFilterFromSettings(this.directoryProfileSettings, kind));
-        const activeProfiles = this.getActiveResourceProfileNames();
-        const profileFilter = mergeResourceProfileFilters(collectNamedResourceProfileFilters(this.globalSettings, kind, activeProfiles), collectNamedResourceProfileFilters(this.projectSettings, kind, activeProfiles), collectNamedResourceProfileFilters(this.directoryProfileSettings, kind, activeProfiles), collectNamedResourceProfileFilters({ resourceProfiles: this.inlineResourceProfileDefinitions }, kind, activeProfiles), collectNamedResourceProfileFilters({ resourceProfiles: this.discoveredResourceProfileDefinitions }, kind, activeProfiles));
+        const profileFilter = {};
+        const seenProfiles = new Set();
+        const registry = this.getProfileRegistry();
+        for (const profileName of this.getActiveResourceProfileNames()) {
+            if (seenProfiles.has(profileName))
+                continue;
+            seenProfiles.add(profileName);
+            appendFilter(profileFilter, registry.getProfile(profileName)?.resources[kind]);
+        }
         const filter = mergeResourceProfileFilters(legacyFilter, profileFilter);
         return {
             allow: [...new Set(filter.allow ?? [])],
@@ -498,14 +613,399 @@ export class SettingsManager {
     /** Add one-shot profile definitions from CLI/SDK/ephemeral agent launch input. Never writes to disk. */
     addInlineResourceProfileDefinitions(profiles) {
         this.inlineResourceProfileDefinitions = mergeResourceProfileMap(this.inlineResourceProfileDefinitions, profiles);
+        this.refreshProfileRegistry();
     }
     /** Replace profile definitions discovered inside loaded resource files. Never writes to disk. */
     replaceDiscoveredResourceProfileDefinitions(profiles) {
         this.discoveredResourceProfileDefinitions = { ...profiles };
+        this.refreshProfileRegistry();
     }
     /** Add profile definitions discovered after resource resolution, e.g. context agent files. Never writes to disk. */
     addDiscoveredResourceProfileDefinitions(profiles) {
         this.discoveredResourceProfileDefinitions = mergeResourceProfileMap(this.discoveredResourceProfileDefinitions, profiles);
+        this.refreshProfileRegistry();
+    }
+    normalizeProfileName(profileName) {
+        const trimmed = profileName.trim();
+        if (!trimmed) {
+            throw new Error("Profile name is required");
+        }
+        const errors = validateSkillName(trimmed);
+        if (errors.length > 0) {
+            throw new Error(`Invalid profile name "${trimmed}": ${errors.join(", ")}`);
+        }
+        return trimmed;
+    }
+    sanitizeProfileResources(resources) {
+        const result = {};
+        for (const kind of ["extensions", "skills", "prompts", "themes", "agents", "tools"]) {
+            const filter = resources[kind];
+            if (!filter) {
+                continue;
+            }
+            result[kind] = {
+                allow: filter.allow ? [...filter.allow] : undefined,
+                block: filter.block ? [...filter.block] : undefined,
+            };
+        }
+        return result;
+    }
+    setActiveProfileInSettings(settings, profileName) {
+        if (profileName) {
+            settings.activeResourceProfile = profileName;
+            settings.activeResourceProfiles = [profileName];
+            return;
+        }
+        delete settings.activeResourceProfiles;
+        delete settings.activeResourceProfile;
+    }
+    persistDirectoryProfiles(update) {
+        const next = structuredClone(this.directoryProfileSettings);
+        update(next);
+        this.directoryProfileSettings = next;
+        this.recomputeSettings();
+        if (!this.directoryProfileInfo) {
+            return;
+        }
+        this.enqueueWrite("directoryProfile", () => {
+            this.storage.withLock("directoryProfile", (current) => {
+                const currentSettings = current
+                    ? SettingsManager.migrateSettings(JSON.parse(current))
+                    : {};
+                const merged = {
+                    ...currentSettings,
+                    ...next,
+                    resourceProfiles: next.resourceProfiles,
+                    activeResourceProfiles: next.activeResourceProfiles,
+                    activeResourceProfile: next.activeResourceProfile,
+                };
+                if (!next.resourceProfiles) {
+                    delete merged.resourceProfiles;
+                }
+                if (!next.activeResourceProfiles && next.activeResourceProfile === undefined) {
+                    delete merged.activeResourceProfiles;
+                    delete merged.activeResourceProfile;
+                }
+                return JSON.stringify(merged, null, 2);
+            });
+        });
+    }
+    getProfileFilePath(profileName) {
+        const normalized = this.normalizeProfileName(profileName);
+        const profilesDir = this.storage.getProfilesDir?.();
+        if (!profilesDir) {
+            throw new Error("Profiles directory is not configured");
+        }
+        return join(resolve(profilesDir), `${normalized}.json`);
+    }
+    /**
+     * Create or update a profile definition in the selected persistence scope.
+     */
+    setProfileDefinition(profileName, definition, scope) {
+        const name = this.normalizeProfileName(profileName);
+        const resources = this.sanitizeProfileResources(definition.resources);
+        if (scope === "session") {
+            const next = { ...this.inlineResourceProfileDefinitions };
+            if (Object.keys(resources).length > 0) {
+                next[name] = resources;
+            }
+            else {
+                delete next[name];
+            }
+            this.inlineResourceProfileDefinitions = next;
+            this.refreshProfileRegistry();
+            return;
+        }
+        if (scope === "global") {
+            const next = structuredClone(this.globalSettings);
+            next.resourceProfiles = { ...(next.resourceProfiles ?? {}) };
+            if (Object.keys(resources).length > 0) {
+                next.resourceProfiles[name] = resources;
+            }
+            else {
+                delete next.resourceProfiles[name];
+            }
+            if (Object.keys(next.resourceProfiles).length === 0) {
+                delete next.resourceProfiles;
+            }
+            this.globalSettings = next;
+            this.markModified("resourceProfiles");
+            this.save();
+            return;
+        }
+        if (scope === "project") {
+            this.updateProjectSettings("resourceProfiles", (settings) => {
+                const next = structuredClone(settings.resourceProfiles ?? {});
+                if (Object.keys(resources).length > 0) {
+                    next[name] = resources;
+                }
+                else {
+                    delete next[name];
+                }
+                if (Object.keys(next).length > 0) {
+                    settings.resourceProfiles = next;
+                }
+                else {
+                    delete settings.resourceProfiles;
+                }
+            });
+            return;
+        }
+        if (scope === "directory") {
+            this.persistDirectoryProfiles((current) => {
+                const next = { ...(current.resourceProfiles ?? {}) };
+                if (Object.keys(resources).length > 0) {
+                    next[name] = resources;
+                }
+                else {
+                    delete next[name];
+                }
+                if (Object.keys(next).length > 0) {
+                    current.resourceProfiles = next;
+                }
+                else {
+                    delete current.resourceProfiles;
+                }
+            });
+            return;
+        }
+        const path = this.getProfileFilePath(name);
+        const existing = existsSync(path)
+            ? parseProfileFileDefinition(readFileSync(path, "utf-8"))
+            : { name, resources: {} };
+        const payload = {
+            ...existing,
+            name,
+            resources,
+            description: definition.description ?? existing.description,
+            model: definition.model ?? existing.model,
+            thinking: definition.thinking ?? existing.thinking,
+        };
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(payload, null, 2), "utf-8");
+    }
+    /**
+     * Delete a profile from the selected scope.
+     */
+    deleteProfile(profileName, scope) {
+        const name = this.normalizeProfileName(profileName);
+        if (scope === "session") {
+            const next = { ...this.inlineResourceProfileDefinitions };
+            delete next[name];
+            this.inlineResourceProfileDefinitions = next;
+            this.refreshProfileRegistry();
+            if (this.runtimeResourceProfiles) {
+                this.setRuntimeResourceProfiles(this.runtimeResourceProfiles.filter((profile) => profile !== name));
+            }
+            return;
+        }
+        if (scope === "global") {
+            const next = { ...(this.globalSettings.resourceProfiles ?? {}) };
+            delete next[name];
+            if (Object.keys(next).length > 0) {
+                this.globalSettings.resourceProfiles = next;
+            }
+            else {
+                delete this.globalSettings.resourceProfiles;
+            }
+            if (this.globalSettings.activeResourceProfile === name) {
+                delete this.globalSettings.activeResourceProfile;
+            }
+            if (this.globalSettings.activeResourceProfiles) {
+                this.globalSettings.activeResourceProfiles = this.globalSettings.activeResourceProfiles.filter((profile) => profile !== name);
+                if (this.globalSettings.activeResourceProfiles.length === 0) {
+                    delete this.globalSettings.activeResourceProfiles;
+                }
+            }
+            this.markModified("resourceProfiles");
+            this.save();
+            return;
+        }
+        if (scope === "project") {
+            this.updateProjectSettings("resourceProfiles", (settings) => {
+                const next = { ...(settings.resourceProfiles ?? {}) };
+                delete next[name];
+                if (Object.keys(next).length > 0) {
+                    settings.resourceProfiles = next;
+                }
+                else {
+                    delete settings.resourceProfiles;
+                }
+                if (settings.activeResourceProfile === name) {
+                    delete settings.activeResourceProfile;
+                }
+                if (settings.activeResourceProfiles) {
+                    settings.activeResourceProfiles = settings.activeResourceProfiles.filter((profile) => profile !== name);
+                    if (settings.activeResourceProfiles.length === 0) {
+                        delete settings.activeResourceProfiles;
+                    }
+                }
+            });
+            return;
+        }
+        if (scope === "directory") {
+            this.persistDirectoryProfiles((current) => {
+                const next = { ...(current.resourceProfiles ?? {}) };
+                delete next[name];
+                if (Object.keys(next).length > 0) {
+                    current.resourceProfiles = next;
+                }
+                else {
+                    delete current.resourceProfiles;
+                }
+                if (current.activeResourceProfile === name) {
+                    delete current.activeResourceProfile;
+                }
+                if (current.activeResourceProfiles) {
+                    current.activeResourceProfiles = current.activeResourceProfiles.filter((profile) => profile !== name);
+                    if (current.activeResourceProfiles.length === 0) {
+                        delete current.activeResourceProfiles;
+                    }
+                }
+            });
+            return;
+        }
+        const profilePath = this.getProfileFilePath(name);
+        if (!existsSync(profilePath)) {
+            throw new Error(`Profile not found: ${name}`);
+        }
+        rmSync(profilePath, { force: true });
+    }
+    renameProfile(profileName, newProfileName, scope) {
+        const oldName = this.normalizeProfileName(profileName);
+        const newName = this.normalizeProfileName(newProfileName);
+        if (oldName === newName) {
+            return;
+        }
+        if (scope === "session") {
+            const profile = this.inlineResourceProfileDefinitions[oldName];
+            if (!profile) {
+                throw new Error(`Profile not found: ${oldName}`);
+            }
+            delete this.inlineResourceProfileDefinitions[oldName];
+            this.inlineResourceProfileDefinitions[newName] = profile;
+            if (this.runtimeResourceProfiles) {
+                this.runtimeResourceProfiles = this.runtimeResourceProfiles.map((name) => name === oldName ? newName : name);
+                this.setRuntimeResourceProfiles(this.runtimeResourceProfiles);
+            }
+            this.refreshProfileRegistry();
+            return;
+        }
+        if (scope === "global") {
+            const next = structuredClone(this.globalSettings);
+            if (!next.resourceProfiles?.[oldName]) {
+                throw new Error(`Profile not found: ${oldName}`);
+            }
+            if (next.resourceProfiles[newName]) {
+                throw new Error(`Profile already exists: ${newName}`);
+            }
+            next.resourceProfiles[newName] = next.resourceProfiles[oldName];
+            delete next.resourceProfiles[oldName];
+            if (next.activeResourceProfile === oldName) {
+                next.activeResourceProfile = newName;
+            }
+            if (next.activeResourceProfiles) {
+                next.activeResourceProfiles = next.activeResourceProfiles.map((name) => name === oldName ? newName : name);
+            }
+            this.globalSettings = next;
+            this.markModified("resourceProfiles");
+            this.markModified("activeResourceProfile");
+            this.markModified("activeResourceProfiles");
+            this.save();
+            return;
+        }
+        if (scope === "project") {
+            this.updateProjectSettings("resourceProfiles", (settings) => {
+                const next = structuredClone(settings.resourceProfiles ?? {});
+                if (!next[oldName]) {
+                    throw new Error(`Profile not found: ${oldName}`);
+                }
+                if (next[newName]) {
+                    throw new Error(`Profile already exists: ${newName}`);
+                }
+                next[newName] = next[oldName];
+                delete next[oldName];
+                settings.resourceProfiles = next;
+                if (settings.activeResourceProfile === oldName) {
+                    settings.activeResourceProfile = newName;
+                }
+                if (settings.activeResourceProfiles) {
+                    settings.activeResourceProfiles = settings.activeResourceProfiles.map((name) => name === oldName ? newName : name);
+                }
+            });
+            return;
+        }
+        if (scope === "directory") {
+            const next = structuredClone(this.directoryProfileSettings.resourceProfiles ?? {});
+            if (!next[oldName]) {
+                throw new Error(`Profile not found: ${oldName}`);
+            }
+            if (next[newName]) {
+                throw new Error(`Profile already exists: ${newName}`);
+            }
+            next[newName] = next[oldName];
+            delete next[oldName];
+            this.persistDirectoryProfiles((current) => {
+                current.resourceProfiles = next;
+                if (current.activeResourceProfile === oldName) {
+                    current.activeResourceProfile = newName;
+                }
+                if (current.activeResourceProfiles) {
+                    current.activeResourceProfiles = current.activeResourceProfiles.map((name) => name === oldName ? newName : name);
+                }
+            });
+            return;
+        }
+        const oldPath = this.getProfileFilePath(oldName);
+        const newPath = this.getProfileFilePath(newName);
+        if (!existsSync(oldPath)) {
+            throw new Error(`Profile not found: ${oldName}`);
+        }
+        if (existsSync(newPath)) {
+            throw new Error(`Profile already exists: ${newName}`);
+        }
+        const parsed = parseProfileFileDefinition(readFileSync(oldPath, "utf-8"));
+        parsed.name = newName;
+        writeFileSync(newPath, JSON.stringify(parsed, null, 2), "utf-8");
+        rmSync(oldPath, { force: true });
+    }
+    /**
+     * Set active profile selection in the selected scope.
+     */
+    setActiveProfile(profileName, scope) {
+        const name = profileName ? this.normalizeProfileName(profileName) : undefined;
+        if (scope === "session") {
+            if (name) {
+                this.setRuntimeResourceProfiles([name]);
+            }
+            else {
+                this.setRuntimeResourceProfiles([]);
+            }
+            return;
+        }
+        if (scope === "global") {
+            if (name) {
+                this.globalSettings.activeResourceProfile = name;
+                this.globalSettings.activeResourceProfiles = [name];
+            }
+            else {
+                delete this.globalSettings.activeResourceProfile;
+                delete this.globalSettings.activeResourceProfiles;
+            }
+            this.markModified("activeResourceProfile");
+            this.markModified("activeResourceProfiles");
+            this.save();
+            return;
+        }
+        if (scope === "project") {
+            this.updateProjectSettings("activeResourceProfile", (settings) => {
+                this.setActiveProfileInSettings(settings, name);
+            });
+            return;
+        }
+        this.persistDirectoryProfiles((current) => {
+            this.setActiveProfileInSettings(current, name);
+        });
     }
     /** Mark a global field as modified during this session */
     markModified(field, nestedKey) {
@@ -733,20 +1233,35 @@ export class SettingsManager {
     getContextGcSettings() {
         return {
             enabled: this.settings.contextGc?.enabled ?? true,
-            preserveRecentMessages: this.settings.contextGc?.preserveRecentMessages ?? 12,
-            minToolResultChars: this.settings.contextGc?.minToolResultChars ?? 2500,
+            preserveRecentMessages: this.settings.contextGc?.preserveRecentMessages ?? 8,
+            minToolResultChars: this.settings.contextGc?.minToolResultChars ?? 1200,
             tools: this.settings.contextGc?.tools ?? [
                 "read",
                 "bash",
                 "rg",
                 "grep",
+                "find",
+                "ls",
+                "skill_open",
+                "automata_graph_status",
+                "automata_graph_search",
+                "automata_graph_query",
+                "automata_graph_neighbors",
+                "automata_graph_path",
+                "automata_graph_pointer_pack",
+                "learning_query_memory",
+                "subagent",
+                "task_steps",
+                "task_background",
+                "task_goal",
+                "run_ledger",
                 "context_headroom_retrieve",
                 "headroom_retrieve",
             ],
             semanticMemory: {
                 enabled: this.settings.contextGc?.semanticMemory?.enabled ?? true,
-                preserveRecentPages: this.settings.contextGc?.semanticMemory?.preserveRecentPages ?? 2,
-                minChars: this.settings.contextGc?.semanticMemory?.minChars ?? 1200,
+                preserveRecentPages: this.settings.contextGc?.semanticMemory?.preserveRecentPages ?? 1,
+                minChars: this.settings.contextGc?.semanticMemory?.minChars ?? 900,
                 markers: this.settings.contextGc?.semanticMemory?.markers ?? [
                     "<automata_context",
                     "<automata_response",
@@ -1086,12 +1601,22 @@ export class SettingsManager {
     setSelfModificationSettings(settings, scope = "global") {
         if (scope === "project") {
             const projectSettings = structuredClone(this.projectSettings);
-            projectSettings.selfModification = { ...settings };
+            const existing = projectSettings.selfModification;
+            projectSettings.selfModification = {
+                ...existing,
+                ...settings,
+                sourcePaths: settings.sourcePaths ?? existing?.sourcePaths,
+            };
             this.markProjectModified("selfModification");
             this.saveProjectSettings(projectSettings);
             return;
         }
-        this.globalSettings.selfModification = { ...settings };
+        const existing = this.globalSettings.selfModification;
+        this.globalSettings.selfModification = {
+            ...existing,
+            ...settings,
+            sourcePaths: settings.sourcePaths ?? existing?.sourcePaths,
+        };
         this.markModified("selfModification");
         this.save();
     }
@@ -1112,7 +1637,12 @@ export class SettingsManager {
         this.save();
     }
     getAutoLearnSettings() {
-        return { ...(this.settings.autoLearn ?? {}) };
+        const settings = this.settings.autoLearn ?? {};
+        return {
+            ...settings,
+            thinkingLevel: settings.thinkingLevel ?? "low",
+            complexTaskToolCalls: settings.complexTaskToolCalls ?? 12,
+        };
     }
     setAutoLearnSettings(settings, scope = "global") {
         if (scope === "project") {