@caupulican/pi-adaptative 0.80.42 → 0.80.45

package/dist/modes/interactive/interactive-mode.js

@@ -18,14 +18,16 @@ import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
-import { cliProviderAliases, defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScope, } from "../../core/model-resolver.js";
+import { cliProviderAliases, defaultModelPerProvider, findExactModelReferenceMatch, resolveCliModel, resolveModelScope, } from "../../core/model-resolver.js";
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
 import { getPendingReloadBlockers } from "../../core/reload-blockers.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
 import { isAutoLearnSessionId, SessionManager } from "../../core/session-manager.js";
+import { validateSkillName } from "../../core/skills.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { isInstallTelemetryEnabled } from "../../core/telemetry.js";
+import { allToolNames } from "../../core/tools/index.js";
 import { hasProjectTrustInputs, ProjectTrustStore } from "../../core/trust-manager.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
@@ -56,6 +58,8 @@ import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./c
 import { LoginDialogComponent } from "./components/login-dialog.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { OAuthSelectorComponent } from "./components/oauth-selector.js";
+import { ProfileResourceEditorComponent, } from "./components/profile-resource-editor.js";
+import { ProfileSelectorComponent } from "./components/profile-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
@@ -101,6 +105,7 @@ const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is acti
 const AUTO_LEARN_DEFAULTS = {
     enabled: false,
     model: "active",
+    thinkingLevel: "low",
     longSessionMessages: 32,
     longSessionContextPercent: 70,
     cooldownMinutes: 24 * 60,
@@ -108,36 +113,39 @@ const AUTO_LEARN_DEFAULTS = {
     maxConcurrentLearners: 1,
     applyHighConfidence: false,
     reflectionReview: true,
-    reflectionMinToolCalls: 5,
+    reflectionMinToolCalls: 12,
     reflectionCooldownMinutes: 24 * 60,
+    complexTaskToolCalls: 12,
 };
 const AUTONOMY_AUTO_LEARN_PRESETS = {
     off: { ...AUTO_LEARN_DEFAULTS, enabled: false, reflectionReview: false },
     safe: {
         ...AUTO_LEARN_DEFAULTS,
-        enabled: true,
+        enabled: false,
         longSessionMessages: 64,
         longSessionContextPercent: 85,
         cooldownMinutes: 24 * 60,
         leaseMinutes: 60,
         maxConcurrentLearners: 1,
         applyHighConfidence: false,
-        reflectionReview: true,
-        reflectionMinToolCalls: 5,
+        reflectionReview: false,
+        reflectionMinToolCalls: 12,
         reflectionCooldownMinutes: 24 * 60,
+        complexTaskToolCalls: 12,
     },
     balanced: {
         ...AUTO_LEARN_DEFAULTS,
-        enabled: true,
+        enabled: false,
         longSessionMessages: 64,
         longSessionContextPercent: 85,
         cooldownMinutes: 24 * 60,
         leaseMinutes: 90,
         maxConcurrentLearners: 1,
         applyHighConfidence: false,
-        reflectionReview: true,
-        reflectionMinToolCalls: 5,
+        reflectionReview: false,
+        reflectionMinToolCalls: 12,
         reflectionCooldownMinutes: 24 * 60,
+        complexTaskToolCalls: 12,
     },
     full: {
         ...AUTO_LEARN_DEFAULTS,
@@ -149,14 +157,13 @@ const AUTONOMY_AUTO_LEARN_PRESETS = {
         maxConcurrentLearners: 1,
         applyHighConfidence: true,
         reflectionReview: true,
-        reflectionMinToolCalls: 5,
+        reflectionMinToolCalls: 12,
         reflectionCooldownMinutes: 24 * 60,
+        complexTaskToolCalls: 12,
     },
 };
 const AUTONOMY_MODES = ["off", "safe", "balanced", "full"];
 const AUTO_LEARN_RESERVATION_MS = 2 * 60 * 1000;
-const AUTO_LEARN_THINKING_LEVEL = "xhigh";
-const AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS = 5;
 export const AUTO_LEARN_HISTORY_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 function definedStringSet(values) {
     const set = new Set();
@@ -434,6 +441,7 @@ export class InteractiveMode {
     skillCommands = new Map();
     // Agent subscription unsubscribe function
     unsubscribe;
+    unsubscribeExtensionsChanged;
     signalCleanupHandlers = [];
     // Track if editor is in bash mode (text starts with !)
     isBashMode = false;
@@ -750,6 +758,10 @@ export class InteractiveMode {
         this.isInitialized = true;
         // Initialize extensions first so resources are shown before messages
         await this.rebindCurrentSession();
+        // Register extensions-changed listener for live reload UI refresh
+        this.unsubscribeExtensionsChanged = this.session.onExtensionsChanged(() => {
+            this.refreshUIAfterExtensionsChanged();
+        });
         // Render initial messages AFTER showing loaded resources
         await this.renderInitialMessages();
         this.renderProjectTrustWarningIfNeeded();
@@ -2437,6 +2449,12 @@ export class InteractiveMode {
                 await this.handleModelCommand(searchTerm);
                 return;
             }
+            if (text === "/profiles" || text.startsWith("/profiles ")) {
+                const rawProfileName = text.startsWith("/profiles ") ? text.slice(10).trim() : undefined;
+                this.editor.setText("");
+                await this.handleProfilesCommand(rawProfileName?.length ? rawProfileName : undefined);
+                return;
+            }
             if (text === "/export" || text.startsWith("/export ")) {
                 await this.handleExportCommand(text);
                 this.editor.setText("");
@@ -4134,6 +4152,8 @@ export class InteractiveMode {
             reflectionReview: settings.reflectionReview ?? preset.reflectionReview,
             reflectionMinToolCalls: settings.reflectionMinToolCalls ?? preset.reflectionMinToolCalls,
             reflectionCooldownMinutes: settings.reflectionCooldownMinutes ?? preset.reflectionCooldownMinutes,
+            complexTaskToolCalls: settings.complexTaskToolCalls ?? preset.complexTaskToolCalls,
+            thinkingLevel: settings.thinkingLevel ?? preset.thinkingLevel,
         };
     }
     getAutoLearnTenantKey() {
@@ -4338,7 +4358,7 @@ export class InteractiveMode {
         const objective = options.kind === "reflection"
             ? "review the latest completed turn for durable memory, skill, validation, tooling, and code-baked self-improvement cues, then run one bounded continuous-learning pass if the learning tools are available"
             : "run one bounded continuous-learning pass for this Pi tenant";
-        return `You are Pi Auto Learn running as a background learner.\n\nObjective: ${objective}.\nTrigger: ${reason}.\n\n${authorityBlock}\n\nRequired workflow:\n1. Query existing durable memory/rules first when tools allow it. Memory confrontation is mandatory before accepting, merging, upgrading, or rejecting learning candidates.\n2. Run the available Auto Learn tooling, preferably learning_run_auto, with applyHighConfidence=${settings.applyHighConfidence}. Process candidate validation in vectorized chunks/batches; avoid scalar per-candidate memory queries except for final selected writes.\n3. Apply the learning validation tree to each candidate chunk: (a) Why is this good for the user? (b) Is it unique, or similar to existing memory/skills/agents so it should merge or upgrade existing knowledge? (c) Will this make Pi a better agent? Candidates that cannot answer all three are noise.\n4. Hermes-style learning cycle: after a complex task (${AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS}+ tool calls), user correction, repeated steering pattern, non-trivial fix/workaround/debugging path, loaded-skill defect, trigger gap, tool gap, or harness workflow defect, actively create or update durable learning artifacts. Memory stores compact facts/preferences/state; skills/prompts/agents/extensions/source store procedural behavior. When a lesson changes how Pi should act on a future class of task, memory alone is not completion.\n5. Skill update preference order: (1) patch the currently loaded or consulted skill that governed the task; (2) patch an existing class-level umbrella skill/agent/prompt; (3) add a support file under references/, templates/, or scripts/ and add a SKILL.md pointer; (4) create a new class-level umbrella skill only when no existing artifact fits. Never create one-off PR/error/codename/session skills.\n6. Behavioral self-improvement is code-baked by default: prefer the lowest durable executable layer that fixes the behavior — patch an existing skill/prompt/agent/extension/tool, tune an approved setting, or edit the authorized Pi source when source authority is available. Use Automata only for concise facts/evidence pointers that support the baked change.\n7. Do not harden transient or environment-dependent failures into durable behavior: missing binaries, fresh-install package gaps, credentials not configured, path mismatches, one-off task narratives, or negative tool-broken claims should become setup/troubleshooting fixes only when the fix itself is reusable.\n8. Treat the latest-turn digest as current-session evidence only; do not auto-commit one-off cues unless deterministic tooling and memory confrontation corroborate them.\n9. In mode=full, apply safe memory/skill/user-extension/authorized-source improvements under the standing grant above; otherwise keep them proposal-gated.\n10. Never cross hard-stop boundaries from the authority policy.\n11. If the learning tools are unavailable, report BLOCKED with the missing tool names and do not improvise.\n12. Finish with PASS, BLOCKED, or FAIL and concise evidence, including chunk counts, merge/upgrade/code-bake decisions, changed paths/settings, validation, and cleanup/purge status.${reflectionBlock}`;
+        return `You are Pi Auto Learn running as a background learner.\n\nObjective: ${objective}.\nTrigger: ${reason}.\n\n${authorityBlock}\n\nRequired workflow:\n1. Query existing durable memory/rules first when tools allow it. Memory confrontation is mandatory before accepting, merging, upgrading, or rejecting learning candidates.\n2. Run the available Auto Learn tooling, preferably learning_run_auto, with applyHighConfidence=${settings.applyHighConfidence}. Process candidate validation in vectorized chunks/batches; avoid scalar per-candidate memory queries except for final selected writes.\n3. Apply the learning validation tree to each candidate chunk: (a) Why is this good for the user? (b) Is it unique, or similar to existing memory/skills/agents so it should merge or upgrade existing knowledge? (c) Will this make Pi a better agent? Candidates that cannot answer all three are noise.\n4. Hermes-style learning cycle: after a complex task (${settings.complexTaskToolCalls}+ tool calls), user correction, repeated steering pattern, non-trivial fix/workaround/debugging path, loaded-skill defect, trigger gap, tool gap, or harness workflow defect, actively create or update durable learning artifacts. Memory stores compact facts/preferences/state; skills/prompts/agents/extensions/source store procedural behavior. When a lesson changes how Pi should act on a future class of task, memory alone is not completion.\n5. Skill update preference order: (1) patch the currently loaded or consulted skill that governed the task; (2) patch an existing class-level umbrella skill/agent/prompt; (3) add a support file under references/, templates/, or scripts/ and add a SKILL.md pointer; (4) create a new class-level umbrella skill only when no existing artifact fits. Never create one-off PR/error/codename/session skills.\n6. Behavioral self-improvement is code-baked by default: prefer the lowest durable executable layer that fixes the behavior — patch an existing skill/prompt/agent/extension/tool, tune an approved setting, or edit the authorized Pi source when source authority is available. Use Automata only for concise facts/evidence pointers that support the baked change.\n7. Do not harden transient or environment-dependent failures into durable behavior: missing binaries, fresh-install package gaps, credentials not configured, path mismatches, one-off task narratives, or negative tool-broken claims should become setup/troubleshooting fixes only when the fix itself is reusable.\n8. Treat the latest-turn digest as current-session evidence only; do not auto-commit one-off cues unless deterministic tooling and memory confrontation corroborate them.\n9. In mode=full, apply safe memory/skill/user-extension/authorized-source improvements under the standing grant above; otherwise keep them proposal-gated.\n10. Never cross hard-stop boundaries from the authority policy.\n11. If the learning tools are unavailable, report BLOCKED with the missing tool names and do not improvise.\n12. Finish with PASS, BLOCKED, or FAIL and concise evidence, including chunk counts, merge/upgrade/code-bake decisions, changed paths/settings, validation, and cleanup/purge status.${reflectionBlock}`;
     }
     reserveAutoLearnRun(params) {
         return this.withAutoLearnStateLock((current) => {
@@ -4468,7 +4488,7 @@ export class InteractiveMode {
         const args = buildAutoLearnSpawnArgs(spawnTarget, {
             name: `Auto Learn ${runId}`,
             modelPattern,
-            thinkingLevel: AUTO_LEARN_THINKING_LEVEL,
+            thinkingLevel: settings.thinkingLevel ?? "low",
             sessionDir,
             sessionId,
             promptPath,
@@ -4630,7 +4650,6 @@ export class InteractiveMode {
     }
     evaluateAutonomyReview(messages) {
         const settings = this.getEffectiveAutoLearnSettings();
-        const autonomy = this.settingsManager.getAutonomySettings();
         const state = this.withAutoLearnStateLock((current) => {
             const pruned = this.pruneAutoLearnHistoryFromState(current);
             return { result: pruned, next: pruned };
@@ -4651,7 +4670,8 @@ export class InteractiveMode {
         const correctionSignal = /\b(next time|for future|from now on|remember this|don't|do not|avoid|instead|you should|should have|you forgot|you missed|not what i asked|wrong again)\b/i.test(userText);
         const behavioralSelfImprovementSignal = /\b(harness|pi|agent|autonomy|autonomous|self[- ]?improv(?:e|ement|ing)?|steer(?:ing)?|trigger(?:s)?|skill(?:s)?|code[- ]?bak(?:e|ed)|bake(?:d)? into code|not (?:automata|memory)|reference agent|hermes)\b/i.test(userText) &&
             /\b(improve|automatic(?:ally)?|autonomous|trigger|fire|skill|steer|self[- ]?improv(?:e|ement|ing)?|code[- ]?bak(?:e|ed)|bake(?:d)?|too much|less)\b/i.test(userText);
-        const complexTaskSignal = toolCalls >= AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS;
+        const complexTaskThreshold = Math.max(1, settings.complexTaskToolCalls ?? 12);
+        const complexTaskSignal = toolCalls >= complexTaskThreshold;
         const bypassCooldown = correctionSignal || behavioralSelfImprovementSignal || complexTaskSignal;
         const base = { messageCount, contextPercent, cooldownRemainingMs, runningCount, toolCalls };
         if (!settings.enabled)
@@ -4690,19 +4710,12 @@ export class InteractiveMode {
             return {
                 ...base,
                 shouldRun: true,
-                reason: `reflection complex task learning signal (${toolCalls}/${AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS} tool calls)`,
+                reason: `reflection complex task learning signal (${toolCalls}/${complexTaskThreshold} tool calls)`,
                 digest: this.buildAutonomyReviewDigest(messages),
                 bypassCooldown: true,
             };
         }
-        if (autonomy.mode === "full") {
-            return {
-                ...base,
-                shouldRun: true,
-                reason: "full autonomy post-turn review",
-                digest: this.buildAutonomyReviewDigest(messages),
-            };
-        }
+        // Full autonomy expands allowed action scope for triggered reviews; it does not make every turn a review trigger.
         if (toolCalls >= settings.reflectionMinToolCalls) {
             return {
                 ...base,
@@ -4859,6 +4872,21 @@ export class InteractiveMode {
     showSettingsSelector() {
         this.showSelector((done) => {
             const projectSettings = this.settingsManager.getProjectSettings();
+            const profileOptions = [
+                {
+                    value: "(none)",
+                    label: "(none)",
+                    description: "Use configured profile selection (session default)",
+                },
+                ...this.settingsManager
+                    .getProfileRegistry()
+                    .listProfiles()
+                    .map((profile) => ({
+                    value: profile.name,
+                    label: profile.name,
+                    description: profile.description ?? profile.source,
+                })),
+            ];
             const selector = new SettingsSelectorComponent({
                 autoCompact: this.session.autoCompactionEnabled,
                 showImages: this.settingsManager.getShowImages(),
@@ -4896,6 +4924,8 @@ export class InteractiveMode {
                 currentModelPattern: this.session.model
                     ? `${this.session.model.provider}/${this.session.model.id}`
                     : undefined,
+                activeProfileName: this.settingsManager.getActiveResourceProfileNames()[0],
+                profileOptions,
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -5038,6 +5068,26 @@ export class InteractiveMode {
                     this.updateAutoLearnFooter();
                     this.showStatus(`Auto Learn settings saved to ${scope}. Use /auto-learn status or /auto-learn run.`);
                 },
+                onProfileChange: (profile) => {
+                    done();
+                    void this.applyProfile(profile);
+                },
+                onProfileCreate: () => {
+                    done();
+                    void this.createProfileFlow();
+                },
+                onProfileEdit: (profileName) => {
+                    done();
+                    void this.openProfileResourceEditor(profileName);
+                },
+                onProfilePersistActive: (scope) => {
+                    done();
+                    this.persistActiveProfile(scope);
+                },
+                onProfileDelete: (profileName) => {
+                    done();
+                    this.deleteProfileFromSource(profileName);
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
@@ -5046,6 +5096,298 @@ export class InteractiveMode {
             return { component: selector, focus: selector.getSettingsList() };
         });
     }
+    async handleProfilesCommand(profileName) {
+        if (profileName) {
+            await this.applyProfile(profileName);
+            return;
+        }
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        if (profiles.length === 0) {
+            this.showWarning("No profiles found. Add resourceProfiles to settings or JSON files under ~/.pi/agent/profiles/.");
+            return;
+        }
+        this.showSelector((done) => {
+            const selector = new ProfileSelectorComponent(profiles, this.settingsManager.getActiveResourceProfileNames(), (profile) => {
+                done();
+                void this.applyProfile(profile);
+            }, () => {
+                done();
+                this.ui.requestRender();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async applyProfile(profileName) {
+        const normalizedName = profileName.trim();
+        const normalizedLower = normalizedName.toLowerCase();
+        if (normalizedName.length === 0 || normalizedLower === "none" || normalizedLower === "(none)") {
+            try {
+                this.settingsManager.setRuntimeResourceProfiles([]);
+                this.session.sessionManager.appendCustomEntry("pi.activeResourceProfiles", {
+                    profiles: [],
+                });
+                await this.handleReloadCommand();
+                const activeProfileName = this.settingsManager.getActiveResourceProfileNames()[0] ?? "(none)";
+                this.footerDataProvider.setExtensionStatus("profile", activeProfileName);
+                this.footer.invalidate();
+                this.updateEditorBorderColor();
+                this.showStatus(`Profile: ${activeProfileName}`);
+            }
+            catch (error) {
+                this.showError(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        const registry = this.settingsManager.getProfileRegistry();
+        const profile = normalizedName.startsWith("./") || normalizedName.startsWith("../")
+            ? registry.resolveProfileRef(normalizedName, this.sessionManager.getCwd())
+            : registry.getProfile(normalizedName);
+        if (!profile) {
+            this.showError(`Profile not found: ${profileName}`);
+            return;
+        }
+        try {
+            let appliedModel;
+            if (profile.model) {
+                this.session.modelRegistry.refresh();
+                const resolved = resolveCliModel({ cliModel: profile.model, modelRegistry: this.session.modelRegistry });
+                if (resolved.error) {
+                    this.showError(resolved.error);
+                    return;
+                }
+                if (resolved.warning) {
+                    this.showWarning(resolved.warning);
+                }
+                if (resolved.model) {
+                    await this.session.setModel(resolved.model, { persistSettings: false });
+                    appliedModel = resolved.model;
+                }
+                if (resolved.thinkingLevel && !profile.thinking) {
+                    this.session.setThinkingLevel(resolved.thinkingLevel, { persistSettings: false });
+                }
+            }
+            if (profile.thinking) {
+                this.session.setThinkingLevel(profile.thinking, { persistSettings: false });
+            }
+            this.settingsManager.setRuntimeResourceProfiles([profile.name]);
+            this.session.sessionManager.appendCustomEntry("pi.activeResourceProfiles", {
+                profiles: [profile.name],
+            });
+            await this.handleReloadCommand();
+            this.footerDataProvider.setExtensionStatus("profile", profile.name);
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+            this.showStatus(`Profile: ${profile.name}`);
+            if (appliedModel) {
+                void this.maybeWarnAboutAnthropicSubscriptionAuth(appliedModel);
+                this.checkDaxnutsEasterEgg(appliedModel);
+            }
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async getProfileResourceKinds() {
+        const loader = this.session.resourceLoader;
+        const base = (p) => p.split(/[\\/]/).pop() ?? p;
+        // Get all discoverable extension paths (enabled and disabled) for profile filtering
+        const allDiscoverableExtensions = await loader.getDiscoverableExtensionPaths();
+        return [
+            { kind: "tools", label: "Tools", allIds: [...allToolNames] },
+            { kind: "skills", label: "Skills", allIds: loader.getSkills().skills.map((s) => s.name) },
+            {
+                kind: "extensions",
+                label: "Extensions",
+                allIds: allDiscoverableExtensions.map((e) => base(e)),
+            },
+            { kind: "agents", label: "Agents", allIds: loader.getAgentsFiles().agentsFiles.map((f) => base(f.path)) },
+            { kind: "prompts", label: "Prompts", allIds: loader.getPrompts().prompts.map((p) => p.name) },
+            { kind: "themes", label: "Themes", allIds: getAvailableThemes() },
+        ];
+    }
+    /** Map where a profile currently lives to the scope we should write it back to. */
+    scopeForProfileSource(source) {
+        switch (source) {
+            case "profile-file":
+                return "reusable-file";
+            case "directory-overlay":
+            case "embedded":
+                return "directory";
+            case "inline":
+                return "session";
+            default:
+                return "global"; // "settings"
+        }
+    }
+    async refreshAfterProfileMutation(profileName) {
+        if (this.settingsManager.getActiveResourceProfileNames().includes(profileName)) {
+            await this.handleReloadCommand();
+            const active = this.settingsManager.getActiveResourceProfileNames()[0] ?? "(none)";
+            this.footerDataProvider.setExtensionStatus("profile", active);
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+        }
+    }
+    async createProfileFlow() {
+        const name = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const input = new ExtensionInputComponent("Create Profile", "Enter profile name", (value) => {
+                    done();
+                    resolve(value);
+                }, () => {
+                    done();
+                    resolve(undefined);
+                }, { tui: this.ui });
+                return { component: input, focus: input };
+            });
+        });
+        if (name === undefined) {
+            this.ui.requestRender();
+            return;
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            this.showError("Profile name cannot be empty");
+            return this.createProfileFlow();
+        }
+        // Validate name rules using validateSkillName
+        const errors = validateSkillName(trimmed);
+        if (errors.length > 0) {
+            this.showError(`Invalid profile name: ${errors.join(", ")}`);
+            return this.createProfileFlow();
+        }
+        // Collision check
+        const existing = this.settingsManager.getProfileRegistry().getProfile(trimmed);
+        if (existing) {
+            this.showError(`Profile "${trimmed}" already exists`);
+            return this.createProfileFlow();
+        }
+        // Open the resource editor on the NEW profile
+        void this.openNewProfileEditor(trimmed);
+    }
+    async openNewProfileEditor(profileName) {
+        const scope = "reusable-file";
+        const kinds = await this.getProfileResourceKinds();
+        this.showSelector((done) => {
+            const editor = new ProfileResourceEditorComponent({
+                profileName,
+                initialResources: {},
+                kinds,
+                onSave: (resources) => {
+                    done();
+                    try {
+                        this.settingsManager.setProfileDefinition(profileName, {
+                            name: profileName,
+                            resources,
+                        }, scope);
+                        this.showStatus(`Saved profile "${profileName}" to ${scope}.`);
+                        this.ui.requestRender();
+                    }
+                    catch (error) {
+                        this.showError(error instanceof Error ? error.message : String(error));
+                    }
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: editor, focus: editor };
+        });
+    }
+    async openProfileResourceEditor(profileName) {
+        const profile = this.settingsManager.getProfileRegistry().getProfile(profileName);
+        if (!profile) {
+            this.showError(`Profile not found: ${profileName}`);
+            return;
+        }
+        const scope = this.scopeForProfileSource(profile.source);
+        const kinds = await this.getProfileResourceKinds();
+        const isActiveProfile = this.settingsManager.getActiveResourceProfileNames().includes(profile.name);
+        const originalResources = profile.resources;
+        this.showSelector((done) => {
+            const editor = new ProfileResourceEditorComponent({
+                profileName: profile.name,
+                initialResources: profile.resources,
+                kinds,
+                onSave: (resources) => {
+                    done();
+                    try {
+                        this.settingsManager.setProfileDefinition(profile.name, {
+                            name: profile.name,
+                            description: profile.description,
+                            model: profile.model,
+                            thinking: profile.thinking,
+                            resources,
+                        }, scope);
+                        this.showStatus(`Saved profile "${profile.name}" to ${scope}.`);
+                        // For active profiles, detect if only extensions changed to avoid full reload
+                        if (isActiveProfile) {
+                            const extensionsChanged = originalResources.extensions !== resources.extensions;
+                            const otherResourcesChanged = originalResources.tools !== resources.tools ||
+                                originalResources.skills !== resources.skills ||
+                                originalResources.agents !== resources.agents ||
+                                originalResources.prompts !== resources.prompts ||
+                                originalResources.themes !== resources.themes;
+                            if (extensionsChanged && !otherResourcesChanged) {
+                                // Only extensions changed: use live reconciliation
+                                void this.reconcileExtensionsAndRefreshUI(profile.name);
+                            }
+                            else {
+                                // Other resources changed or mixed: use full reload
+                                void this.refreshAfterProfileMutation(profile.name);
+                            }
+                        }
+                        // Non-active profiles don't need refresh
+                    }
+                    catch (error) {
+                        this.showError(error instanceof Error ? error.message : String(error));
+                    }
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: editor, focus: editor };
+        });
+    }
+    persistActiveProfile(scope) {
+        const active = this.settingsManager.getActiveResourceProfileNames()[0];
+        if (!active) {
+            this.showError("No active profile to persist. Select one with /profiles first.");
+            return;
+        }
+        try {
+            if (scope === "session") {
+                this.settingsManager.setRuntimeResourceProfiles([active]);
+            }
+            else {
+                this.settingsManager.setActiveProfile(active, scope);
+            }
+            this.showStatus(`Active profile "${active}" persisted to ${scope}.`);
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    deleteProfileFromSource(profileName) {
+        const profile = this.settingsManager.getProfileRegistry().getProfile(profileName);
+        if (!profile) {
+            this.showError(`Profile not found: ${profileName}`);
+            return;
+        }
+        const scope = this.scopeForProfileSource(profile.source);
+        try {
+            this.settingsManager.deleteProfile(profileName, scope);
+            this.showStatus(`Deleted profile "${profileName}" from ${scope}.`);
+            void this.refreshAfterProfileMutation(profileName);
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
     async handleModelCommand(searchTerm) {
         if (!searchTerm) {
             await this.showModelSelector();
@@ -5916,6 +6258,71 @@ export class InteractiveMode {
             this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Refresh UI after extensions are loaded/unloaded live.
+     * Performs the same refresh calls as handleReloadCommand but without the full reload.
+     */
+    async refreshUIAfterExtensionsChanged() {
+        try {
+            // Refresh keybindings and autocomplete
+            this.keybindings.reload();
+            this.setupAutocompleteProvider();
+            // Refresh themes
+            const activeHeader = this.customHeader ?? this.builtInHeader;
+            if (isExpandable(activeHeader)) {
+                activeHeader.setExpanded(this.toolOutputExpanded);
+            }
+            setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+            this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+            const themeName = this.settingsManager.getTheme();
+            const themeResult = themeName ? setTheme(themeName, true) : { success: true };
+            if (!themeResult.success) {
+                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
+            }
+            // Refresh editor settings
+            const editorPaddingX = this.settingsManager.getEditorPaddingX();
+            const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
+            this.defaultEditor.setPaddingX(editorPaddingX);
+            this.defaultEditor.setAutocompleteMaxVisible(autocompleteMaxVisible);
+            if (this.editor !== this.defaultEditor) {
+                this.editor.setPaddingX?.(editorPaddingX);
+                this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
+            }
+            // Refresh extension shortcuts
+            const runner = this.session.extensionRunner;
+            this.setupExtensionShortcuts(runner);
+            // Refresh chat and UI
+            await this.rebuildChatFromMessages();
+            this.footer.invalidate();
+            this.ui.requestRender();
+        }
+        catch (error) {
+            this.showError(`Extension refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Reconcile extensions for the active profile and refresh UI.
+     * Used when only extensions change in the active profile to avoid full reload.
+     */
+    async reconcileExtensionsAndRefreshUI(profileName) {
+        try {
+            await this.session.reconcileLoadedExtensions();
+            const active = this.settingsManager.getActiveResourceProfileNames()[0] ?? "(none)";
+            this.footerDataProvider.setExtensionStatus("profile", active);
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+        }
+        catch (error) {
+            // On error, fall back to full reload
+            try {
+                await this.refreshAfterProfileMutation(profileName);
+            }
+            catch {
+                // If full reload also fails, show error
+                this.showError(`Failed to reconcile extensions: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
     async handleExportCommand(text) {
         const outputPath = this.getPathCommandArgument(text, "/export");
         try {
@@ -6466,6 +6873,9 @@ export class InteractiveMode {
         if (this.unsubscribe) {
             this.unsubscribe();
         }
+        if (this.unsubscribeExtensionsChanged) {
+            this.unsubscribeExtensionsChanged();
+        }
         if (this.isInitialized) {
             this.ui.stop();
             this.isInitialized = false;