@caupulican/pi-adaptative 0.80.47 → 0.80.49

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

@@ -32,6 +32,7 @@ import { hasProjectTrustInputs, ProjectTrustStore } from "../../core/trust-manag
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { readClipboardImage } from "../../utils/clipboard-image.js";
+import { parseFrontmatter } from "../../utils/frontmatter.js";
 import { parseGitUrl } from "../../utils/git.js";
 import { getCwdRelativePath, resolvePath } from "../../utils/paths.js";
 import { getPiUserAgent } from "../../utils/pi-user-agent.js";
@@ -58,7 +59,7 @@ 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 { ProfileResourceEditorComponent, resolveResourceEditPath, } 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";
@@ -3717,6 +3718,50 @@ export class InteractiveMode {
             this.ui.requestRender(true);
         }
     }
+    async openEditorForPath(filePath) {
+        let editorCmd = process.env.EDITOR || process.env.VISUAL;
+        let isFallback = false;
+        if (!editorCmd) {
+            editorCmd = "vi";
+            isFallback = true;
+        }
+        try {
+            // Stop TUI to release terminal
+            this.ui.stop();
+            // Split by space to support editor arguments (e.g., "code --wait")
+            const [editor, ...editorArgs] = editorCmd.split(" ");
+            process.stdout.write(`Launching external editor: ${editorCmd} ${filePath}\nPi will resume when the editor exits.\n`);
+            const status = await new Promise((resolve) => {
+                const child = spawn(editor, [...editorArgs, filePath], {
+                    stdio: "inherit",
+                    shell: process.platform === "win32",
+                });
+                child.on("error", () => resolve(null));
+                child.on("close", (code) => resolve(code));
+            });
+            if (status === null) {
+                if (isFallback) {
+                    process.stdout.write(`\nError: Failed to launch fallback editor "vi".\n`);
+                }
+                else {
+                    process.stdout.write(`\nError: Failed to launch editor "${editorCmd}".\n`);
+                }
+                process.stdout.write(`Please set the $EDITOR or $VISUAL environment variable to edit inline.\n`);
+                process.stdout.write(`Absolute file path: ${filePath}\n\nPress Enter to return to Pi...`);
+                // Wait for enter key
+                await new Promise((resolve) => {
+                    process.stdin.once("data", () => resolve());
+                });
+            }
+            return status === 0;
+        }
+        finally {
+            // Restart TUI
+            this.ui.start();
+            // Force full re-render since external editor uses alternate screen
+            this.ui.requestRender(true);
+        }
+    }
     // =========================================================================
     // UI helpers
     // =========================================================================
@@ -5088,40 +5133,487 @@ export class InteractiveMode {
                     this.updateAutoLearnFooter();
                     this.showStatus(`Auto Learn settings saved to ${scope}. Use /auto-learn status or /auto-learn run.`);
                 },
-                onProfileChange: (profile) => {
+                onResourcesHubAction: (action) => {
                     done();
-                    void this.applyProfile(profile);
+                    void this.handleResourcesHubAction(action);
                 },
-                onProfileCreate: () => {
+                onCancel: () => {
                     done();
-                    void this.createProfileFlow();
+                    this.ui.requestRender();
                 },
-                onProfileEdit: (profileName) => {
+            });
+            return { component: selector, focus: selector.getSettingsList() };
+        });
+    }
+    async handleResourcesHubAction(action) {
+        switch (action) {
+            case "nudge-add-source":
+                void this.addExternalResourceRootFlow().then(() => {
+                    void this.showSettingsSelector();
+                });
+                break;
+            case "active-profile":
+                void this.openActiveProfileSelector();
+                break;
+            case "manage-library":
+                void this.openLibraryManagerFlow();
+                break;
+            case "manage-profiles":
+                void this.openManageProfilesFlow();
+                break;
+            case "sources":
+                void this.openSourcesManagerFlow();
+                break;
+        }
+    }
+    async openActiveProfileSelector() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        const activeNames = this.settingsManager.getActiveResourceProfileNames();
+        const options = [
+            { value: "(none)", label: "(none)", description: "No active profile/situation (all resources enabled)" },
+            ...profiles.map((p) => ({
+                value: p.name,
+                label: p.name,
+                description: p.description || p.source,
+            })),
+        ];
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Profile / Situation", "Select the active runtime profile/situation for this session. This is session-only unless saved elsewhere.", options, activeNames[0] || "(none)", (value) => {
+                done();
+                void this.applyProfile(value === "(none)" ? "" : value).then(() => {
+                    void this.showSettingsSelector();
+                });
+            }, () => {
+                done();
+                void this.showSettingsSelector();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openManageProfilesFlow() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        const editableProfiles = profiles.map((p) => ({
+            value: p.name,
+            label: p.name,
+            description: p.description || p.source,
+        }));
+        const options = [
+            {
+                value: "create",
+                label: "+ Create profile / situation...",
+                description: "Create a new resource profile/situation definition.",
+            },
+        ];
+        if (this.settingsManager.getActiveResourceProfileNames().length > 0) {
+            options.push({
+                value: "persist",
+                label: "Persist active profile / situation to...",
+                description: "Save the current active profile/situation selection so it survives restart.",
+            });
+        }
+        if (editableProfiles.length > 0) {
+            options.push({
+                value: "delete",
+                label: "Delete profile / situation...",
+                description: "Remove a profile/situation definition from where it is stored.",
+            });
+        }
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Manage Profiles / Situations", "Create, delete, or persist profile/situation definitions.", options, "", (value) => {
+                done();
+                if (value === "create") {
+                    void this.createProfileFlow().then(() => {
+                        void this.showSettingsSelector();
+                    });
+                }
+                else if (value === "persist") {
+                    void this.openPersistProfileSelector();
+                }
+                else if (value === "delete") {
+                    void this.openDeleteProfileSelector();
+                }
+            }, () => {
+                done();
+                void this.showSettingsSelector();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openPersistProfileSelector() {
+        const scopeOptions = [
+            { value: "session", label: "session", description: "Runtime only (not written to disk)" },
+            {
+                value: "directory",
+                label: "directory",
+                description: "~/.pi/agent/resource-profiles/<hash>/settings.json",
+            },
+            { value: "project", label: "project", description: ".pi/settings.json" },
+            { value: "global", label: "global", description: "~/.pi/agent/settings.json" },
+        ];
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Persist Active Profile / Situation", "Choose where to write the active profile/situation selection.", scopeOptions, "directory", (value) => {
+                done();
+                this.persistActiveProfile(value);
+                void this.showSettingsSelector();
+            }, () => {
+                done();
+                void this.openManageProfilesFlow();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openDeleteProfileSelector() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const editableProfiles = registry.listProfiles().map((p) => ({
+            value: p.name,
+            label: p.name,
+            description: p.description || p.source,
+        }));
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Delete Profile / Situation", "Pick a profile/situation to delete.", editableProfiles, "", (value) => {
+                done();
+                this.deleteProfileFromSource(value);
+                void this.showSettingsSelector();
+            }, () => {
+                done();
+                void this.openManageProfilesFlow();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openSourcesManagerFlow() {
+        const externalRoots = this.settingsManager.getExternalResourceRoots();
+        const trustedRoots = this.settingsManager.getTrustedResourceRoots();
+        const options = [
+            {
+                value: "add",
+                label: "+ Add external root...",
+                description: "Register a new external directory root (requires trust)",
+            },
+        ];
+        for (const r of externalRoots) {
+            const isTrusted = trustedRoots.includes(r);
+            options.push({
+                value: `remove:${r}`,
+                label: `Remove: ${r}`,
+                description: isTrusted ? "Trusted external root" : "Untrusted external root",
+            });
+        }
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Sources", "Manage external resource roots. Adding a root requires trust confirmation.", options, "", (value) => {
+                done();
+                if (value === "add") {
+                    void this.addExternalResourceRootFlow().then(() => {
+                        void this.showSettingsSelector();
+                    });
+                }
+                else if (value.startsWith("remove:")) {
+                    const root = value.slice("remove:".length);
+                    void this.removeExternalResourceRootFlow(root).then(() => {
+                        void this.showSettingsSelector();
+                    });
+                }
+            }, () => {
+                done();
+                void this.showSettingsSelector();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openLibraryManagerFlow() {
+        const activeNames = this.settingsManager.getActiveResourceProfileNames();
+        const activeName = activeNames[0];
+        if (!activeName || activeName === "(none)") {
+            this.showSelector((done) => {
+                const selector = new SelectSubmenu("No Active Profile / Situation", "Select or create a profile/situation to manage the library.", [
+                    {
+                        value: "select",
+                        label: "Select existing profile / situation...",
+                        description: "Choose an existing profile/situation to activate.",
+                    },
+                    {
+                        value: "create",
+                        label: "Create new profile / situation...",
+                        description: "Create a new profile/situation definition.",
+                    },
+                ], "select", (value) => {
                     done();
-                    void this.openProfileResourceEditor(profileName);
-                },
-                onProfilePersistActive: (scope) => {
+                    if (value === "create") {
+                        void this.createProfileAndOpenLibraryFlow();
+                    }
+                    else {
+                        void this.selectProfileAndOpenLibraryFlow();
+                    }
+                }, () => {
                     done();
-                    this.persistActiveProfile(scope);
-                },
-                onProfileDelete: (profileName) => {
+                    void this.showSettingsSelector();
+                });
+                return { component: selector, focus: selector.getSelectList() };
+            });
+            return;
+        }
+        const registry = this.settingsManager.getProfileRegistry();
+        const profile = registry.getProfile(activeName);
+        if (!profile) {
+            this.showError(`Active profile/situation "${activeName}" not found in registry.`);
+            return;
+        }
+        const scope = this.scopeForProfileSource(profile.source);
+        void this.openLibraryEditorForProfile(profile.name, scope);
+    }
+    async createProfileAndOpenLibraryFlow() {
+        const name = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const input = new ExtensionInputComponent("Create Profile / Situation", "Enter profile/situation name", (value) => {
+                    done();
+                    resolve(value);
+                }, () => {
+                    done();
+                    resolve(undefined);
+                }, { tui: this.ui });
+                return { component: input, focus: input };
+            });
+        });
+        if (name === undefined) {
+            void this.openLibraryManagerFlow();
+            return;
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            this.showWarning("Profile/situation name cannot be empty.");
+            void this.openLibraryManagerFlow();
+            return;
+        }
+        try {
+            this.settingsManager.setProfileDefinition(trimmed, {
+                name: trimmed,
+                resources: {},
+            }, "directory");
+            await this.applyProfile(trimmed);
+            void this.openLibraryEditorForProfile(trimmed, "directory");
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+            void this.openLibraryManagerFlow();
+        }
+    }
+    async selectProfileAndOpenLibraryFlow() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        const editableProfiles = profiles.map((p) => ({
+            value: p.name,
+            label: p.name,
+            description: p.description || p.source,
+        }));
+        if (editableProfiles.length === 0) {
+            this.showWarning("No existing profiles/situations to select. Please create one.");
+            void this.createProfileAndOpenLibraryFlow();
+            return;
+        }
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Select Profile / Situation", "Pick a profile/situation to activate and edit.", editableProfiles, "", (value) => {
+                done();
+                void this.applyProfile(value).then(() => {
+                    const profile = registry.getProfile(value);
+                    const scope = this.scopeForProfileSource(profile.source);
+                    void this.openLibraryEditorForProfile(value, scope);
+                });
+            }, () => {
+                done();
+                void this.openLibraryManagerFlow();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async getProfileResourceKinds() {
+        const loader = this.session.resourceLoader;
+        const base = (p) => p.split(/[\\/]/).pop() ?? p;
+        const allDiscoverableExtensions = await loader.getDiscoverableExtensionPaths();
+        const skills = loader.getSkills().skills;
+        const prompts = loader.getPrompts().prompts;
+        const themes = getAvailableThemesWithPaths();
+        const agents = loader.getAgentsFiles().agentsFiles;
+        const getAgentDescription = (filePath) => {
+            try {
+                const content = fs.readFileSync(filePath, "utf-8");
+                const { frontmatter } = parseFrontmatter(content);
+                if (typeof frontmatter.description === "string") {
+                    return frontmatter.description;
+                }
+            }
+            catch { }
+            return undefined;
+        };
+        const getExtensionDescription = (filePath) => {
+            try {
+                let dir = filePath;
+                if (fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()) {
+                    dir = path.dirname(filePath);
+                }
+                const pkgPath = path.join(dir, "package.json");
+                if (fs.existsSync(pkgPath)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                    if (typeof pkg.description === "string") {
+                        return pkg.description;
+                    }
+                }
+            }
+            catch { }
+            return undefined;
+        };
+        return [
+            {
+                kind: "tools",
+                label: "Tools",
+                items: Array.from(allToolNames).map((name) => ({ id: name })),
+            },
+            {
+                kind: "skills",
+                label: "Skills",
+                items: skills.map((s) => ({
+                    id: s.name,
+                    path: s.filePath,
+                    description: s.description,
+                })),
+            },
+            {
+                kind: "extensions",
+                label: "Extensions",
+                items: allDiscoverableExtensions.map((e) => ({
+                    id: base(e),
+                    path: e,
+                    description: getExtensionDescription(e),
+                })),
+            },
+            {
+                kind: "agents",
+                label: "Agents",
+                items: agents.map((f) => ({
+                    id: base(f.path),
+                    path: f.path,
+                    description: getAgentDescription(f.path),
+                })),
+            },
+            {
+                kind: "prompts",
+                label: "Prompts",
+                items: prompts.map((p) => ({
+                    id: p.name,
+                    path: p.filePath,
+                    description: p.description,
+                })),
+            },
+            {
+                kind: "themes",
+                label: "Themes",
+                items: themes.map((t) => ({
+                    id: t.name,
+                    path: t.path,
+                })),
+            },
+        ];
+    }
+    async openLibraryEditorForProfile(profileName, initialScope) {
+        const currentScope = initialScope;
+        const registry = this.settingsManager.getProfileRegistry();
+        const profile = registry.getProfile(profileName);
+        if (!profile) {
+            this.showError(`Profile not found: ${profileName}`);
+            return;
+        }
+        const kinds = await this.getProfileResourceKinds();
+        const originalResources = profile.resources;
+        const isActiveProfile = this.settingsManager.getActiveResourceProfileNames().includes(profile.name);
+        this.showSelector((done) => {
+            const editor = new ProfileResourceEditorComponent({
+                profileName: profile.name,
+                profileScope: currentScope,
+                initialResources: profile.resources,
+                kinds,
+                cwd: this.sessionManager.getCwd(),
+                agentDir: getAgentDir(),
+                externalResourceRoots: this.settingsManager.getExternalResourceRoots(),
+                onSave: (resources) => {
                     done();
-                    this.deleteProfileFromSource(profileName);
+                    try {
+                        this.settingsManager.setProfileDefinition(profileName, {
+                            name: profileName,
+                            description: profile.description,
+                            model: profile.model,
+                            thinking: profile.thinking,
+                            resources,
+                        }, currentScope);
+                        this.showStatus(`Saved profile "${profileName}" to ${currentScope}.`);
+                        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) {
+                                void this.reconcileExtensionsAndRefreshUI(profileName);
+                            }
+                            else {
+                                void this.refreshAfterProfileMutation(profileName);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.showError(error instanceof Error ? error.message : String(error));
+                    }
                 },
-                onAddExternalResourceRoot: () => {
+                onCancel: () => {
                     done();
-                    void this.addExternalResourceRootFlow();
+                    void this.openLibraryManagerFlow();
                 },
-                onRemoveExternalResourceRoot: (root) => {
+                onScopeChange: () => {
                     done();
-                    void this.removeExternalResourceRootFlow(root);
+                    void this.promptScopeChangeForProfile(profileName, currentScope);
                 },
-                onCancel: () => {
+                onEdit: async (id, pathValue, kind) => {
                     done();
-                    this.ui.requestRender();
+                    const resolvedEditPath = resolveResourceEditPath(id, pathValue, kind);
+                    if (!resolvedEditPath) {
+                        this.showWarning(`Resource "${id}" of kind "${kind}" has no editable file path.`);
+                        void this.openLibraryEditorForProfile(profileName, currentScope);
+                        return;
+                    }
+                    if (!fs.existsSync(resolvedEditPath)) {
+                        this.showError(`Resolved path for "${id}" does not exist: ${resolvedEditPath}`);
+                        void this.openLibraryEditorForProfile(profileName, currentScope);
+                        return;
+                    }
+                    await this.openEditorForPath(resolvedEditPath);
+                    await this.handleReloadCommand();
+                    void this.openLibraryEditorForProfile(profileName, currentScope);
                 },
             });
-            return { component: selector, focus: selector.getSettingsList() };
+            return { component: editor, focus: editor };
+        });
+    }
+    async promptScopeChangeForProfile(profileName, currentScope) {
+        const scopeOptions = [
+            { value: "session", label: "session", description: "Runtime only (not written to disk)" },
+            {
+                value: "directory",
+                label: "directory",
+                description: "~/.pi/agent/resource-profiles/<hash>/settings.json",
+            },
+            { value: "project", label: "project", description: ".pi/settings.json" },
+            { value: "global", label: "global", description: "~/.pi/agent/settings.json" },
+        ];
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Change Profile / Situation Scope", `Select new scope for profile/situation "${profileName}".`, scopeOptions, currentScope, (value) => {
+                done();
+                void this.openLibraryEditorForProfile(profileName, value);
+            }, () => {
+                done();
+                void this.openLibraryEditorForProfile(profileName, currentScope);
+            });
+            return { component: selector, focus: selector.getSelectList() };
         });
     }
     async handleProfilesCommand(profileName) {
@@ -5216,24 +5708,6 @@ export class InteractiveMode {
             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) {
@@ -5260,7 +5734,7 @@ export class InteractiveMode {
     async createProfileFlow() {
         const name = await new Promise((resolve) => {
             this.showSelector((done) => {
-                const input = new ExtensionInputComponent("Create Profile", "Enter profile name", (value) => {
+                const input = new ExtensionInputComponent("Create Profile / Situation", "Enter profile/situation name", (value) => {
                     done();
                     resolve(value);
                 }, () => {
@@ -5276,19 +5750,19 @@ export class InteractiveMode {
         }
         const trimmed = name.trim();
         if (!trimmed) {
-            this.showError("Profile name cannot be empty");
+            this.showError("Profile/situation 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(", ")}`);
+            this.showError(`Invalid profile/situation name: ${errors.join(", ")}`);
             return this.createProfileFlow();
         }
         // Collision check
         const existing = this.settingsManager.getProfileRegistry().getProfile(trimmed);
         if (existing) {
-            this.showError(`Profile "${trimmed}" already exists`);
+            this.showError(`Profile/situation "${trimmed}" already exists`);
             return this.createProfileFlow();
         }
         // Open the resource editor on the NEW profile
@@ -5300,8 +5774,12 @@ export class InteractiveMode {
         this.showSelector((done) => {
             const editor = new ProfileResourceEditorComponent({
                 profileName,
+                profileScope: scope,
                 initialResources: {},
                 kinds,
+                cwd: this.sessionManager.getCwd(),
+                agentDir: getAgentDir(),
+                externalResourceRoots: this.settingsManager.getExternalResourceRoots(),
                 onSave: (resources) => {
                     done();
                     try {
@@ -5320,62 +5798,22 @@ export class InteractiveMode {
                     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) => {
+                onEdit: async (id, pathValue, kind) => {
                     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
+                    const resolvedEditPath = resolveResourceEditPath(id, pathValue, kind);
+                    if (!resolvedEditPath) {
+                        this.showWarning(`Resource "${id}" of kind "${kind}" has no editable file path.`);
+                        void this.openNewProfileEditor(profileName);
+                        return;
                     }
-                    catch (error) {
-                        this.showError(error instanceof Error ? error.message : String(error));
+                    if (!fs.existsSync(resolvedEditPath)) {
+                        this.showError(`Resolved path for "${id}" does not exist: ${resolvedEditPath}`);
+                        void this.openNewProfileEditor(profileName);
+                        return;
                     }
-                },
-                onCancel: () => {
-                    done();
-                    this.ui.requestRender();
+                    await this.openEditorForPath(resolvedEditPath);
+                    await this.handleReloadCommand();
+                    void this.openNewProfileEditor(profileName);
                 },
             });
             return { component: editor, focus: editor };