@codingame/monaco-vscode-chat-service-override 28.4.0 → 29.0.0

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginServiceImpl.js

@@ -1,15 +1,17 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
 import { untildify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { cloneAndChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { cloneAndChange, equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import { joinPath, basename, extname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { joinPath, normalizePath, isEqualOrParent, basename, extname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { ConfigurationTarget, getConfigValueInTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
@@ -18,25 +20,31 @@ import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { EnablementModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
 import { parseClaudeHooks } from '../promptSyntax/hookClaudeCompat.js';
 import { parseCopilotHooks } from '../promptSyntax/hookCompatibility.js';
-import { agentPluginDiscoveryRegistry } from './agentPluginService.js';
 import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
+import { agentPluginDiscoveryRegistry } from './agentPluginService.js';
 import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
 
 const COMMAND_FILE_SUFFIX = ".md";
+const RULE_FILE_SUFFIXES = [".instructions.md", ".mdc", ".md"];
 var AgentPluginFormat;
 (function(AgentPluginFormat) {
     AgentPluginFormat[AgentPluginFormat["Copilot"] = 0] = "Copilot";
     AgentPluginFormat[AgentPluginFormat["Claude"] = 1] = "Claude";
+    AgentPluginFormat[AgentPluginFormat["OpenPlugin"] = 2] = "OpenPlugin";
 })(AgentPluginFormat || (AgentPluginFormat = {}));
-function mapParsedHooks(parsed) {
+function mapParsedHooks(uri, parsed) {
     return ( [...parsed.entries()].map((
         [type, {
             hooks,
@@ -44,6 +52,7 @@ function mapParsedHooks(parsed) {
         }]
     ) => ({
         type,
+        uri,
         hooks,
         originalId
     })));
@@ -57,18 +66,19 @@ let CopilotPluginFormatAdapter = class CopilotPluginFormatAdapter {
     constructor(_workspaceContextService) {
         this._workspaceContextService = _workspaceContextService;
         this.format = AgentPluginFormat.Copilot;
-        this.manifestPaths = ["plugin.json"];
-        this.hookConfigPaths = ["hooks.json"];
-        this.hookWatchPaths = ["hooks.json"];
+        this.manifestPath = "plugin.json";
+        this.hookConfigPath = "hooks.json";
+        this.pluginRootToken = undefined;
+        this.pluginRootEnvVar = undefined;
     }
-    parseHooks(json, pluginUri, userHome) {
+    parseHooks(hookURI, json, pluginUri, userHome) {
         const workspaceRoot = resolveWorkspaceRoot(pluginUri, this._workspaceContextService);
-        return mapParsedHooks(parseCopilotHooks(json, workspaceRoot, userHome));
+        return mapParsedHooks(hookURI, parseCopilotHooks(json, workspaceRoot, userHome));
     }
 };
 CopilotPluginFormatAdapter = ( __decorate([( __param(0, IWorkspaceContextService))], CopilotPluginFormatAdapter));
 const shellUnsafeChars = /[\s&|<>()^;!`"']/;
-function shellQuotePluginRootInCommand(command, fsPath, token = "${CLAUDE_PLUGIN_ROOT}") {
+function shellQuotePluginRootInCommand(command, fsPath, token) {
     if (!command.includes(token)) {
         return command;
     }
@@ -86,87 +96,210 @@ function shellQuotePluginRootInCommand(command, fsPath, token = "${CLAUDE_PLUGIN
         return "\"" + fullPath.replace(/"/g, "\\\"") + "\"";
     });
 }
-let ClaudePluginFormatAdapter = class ClaudePluginFormatAdapter {
-    constructor(_workspaceContextService) {
-        this._workspaceContextService = _workspaceContextService;
-        this.format = AgentPluginFormat.Claude;
-        this.manifestPaths = [".claude-plugin/plugin.json"];
-        this.hookConfigPaths = ["hooks/hooks.json"];
-        this.hookWatchPaths = ["hooks"];
-    }
-    parseHooks(json, pluginUri, userHome) {
-        const token = "${CLAUDE_PLUGIN_ROOT}";
-        const fsPath = pluginUri.fsPath;
-        const typedJson = json;
-        const mutateHookCommand = hook => {
-            for (const field of ["command", "windows", "linux", "osx"]) {
-                if (typeof hook[field] === "string") {
-                    hook[field] = shellQuotePluginRootInCommand(hook[field], fsPath, token);
-                }
+function resolveMcpServersMap(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const obj = raw;
+    return Object.hasOwn(obj, "mcpServers") ? obj.mcpServers : obj;
+}
+function interpolateMcpPluginRoot(def, fsPath, token, envVar) {
+    const replace = s => s.replaceAll(token, fsPath);
+    const config = def.configuration;
+    let interpolated;
+    if (config.type === McpServerType.LOCAL) {
+        const local = {
+            ...config
+        };
+        local.command = replace(local.command);
+        if (local.args) {
+            local.args = ( local.args.map(replace));
+        }
+        if (local.cwd) {
+            local.cwd = replace(local.cwd);
+        }
+        local.env = {
+            ...local.env
+        };
+        for (const [k, v] of Object.entries(local.env)) {
+            if (typeof v === "string") {
+                local.env[k] = replace(v);
             }
-            hook.env ??= {};
-            hook.env.CLAUDE_PLUGIN_ROOT = fsPath;
+        }
+        local.env[envVar] = fsPath;
+        if (local.envFile) {
+            local.envFile = replace(local.envFile);
+        }
+        interpolated = local;
+    } else {
+        const remote = {
+            ...config
         };
-        for (const lifecycle of ( Object.values(typedJson.hooks ?? {}))) {
-            if (!Array.isArray(lifecycle)) {
+        remote.url = replace(remote.url);
+        if (remote.headers) {
+            remote.headers = Object.fromEntries(( Object.entries(remote.headers).map(([k, v]) => [k, replace(v)])));
+        }
+        interpolated = remote;
+    }
+    return {
+        name: def.name,
+        configuration: interpolated,
+        uri: def.uri
+    };
+}
+function parsePluginRootHooks(hookURI, json, pluginUri, userHome, workspaceContextService, token, envVar) {
+    const fsPath = pluginUri.fsPath;
+    const typedJson = json;
+    const mutateHookCommand = hook => {
+        for (const field of ["command", "windows", "linux", "osx"]) {
+            if (typeof hook[field] === "string") {
+                hook[field] = shellQuotePluginRootInCommand(hook[field], fsPath, token);
+            }
+        }
+        hook.env ??= {};
+        hook.env[envVar] = fsPath;
+    };
+    for (const lifecycle of ( Object.values(typedJson.hooks ?? {}))) {
+        if (!Array.isArray(lifecycle)) {
+            continue;
+        }
+        for (const lifecycleEntry of lifecycle) {
+            if (!lifecycleEntry || typeof lifecycleEntry !== "object") {
                 continue;
             }
-            for (const lifecycleEntry of lifecycle) {
-                if (!lifecycleEntry || typeof lifecycleEntry !== "object") {
-                    continue;
-                }
-                const entry = lifecycleEntry;
-                if (Array.isArray(entry.hooks)) {
-                    for (const hook of entry.hooks) {
-                        mutateHookCommand(hook);
-                    }
-                } else {
-                    mutateHookCommand(entry);
+            const entry = lifecycleEntry;
+            if (Array.isArray(entry.hooks)) {
+                for (const hook of entry.hooks) {
+                    mutateHookCommand(hook);
                 }
+            } else {
+                mutateHookCommand(entry);
             }
         }
-        const replacer = v => {
-            return typeof v === "string" ? v.replaceAll("${CLAUDE_PLUGIN_ROOT}", pluginUri.fsPath) : undefined;
-        };
-        const workspaceRoot = resolveWorkspaceRoot(pluginUri, this._workspaceContextService);
-        const {
-            hooks,
-            disabledAllHooks
-        } = parseClaudeHooks(cloneAndChange(json, replacer), workspaceRoot, userHome);
-        if (disabledAllHooks) {
-            return [];
-        }
-        return mapParsedHooks(hooks);
+    }
+    const replacer = v => {
+        return typeof v === "string" ? v.replaceAll(token, pluginUri.fsPath) : undefined;
+    };
+    const workspaceRoot = resolveWorkspaceRoot(pluginUri, workspaceContextService);
+    const {
+        hooks,
+        disabledAllHooks
+    } = parseClaudeHooks(cloneAndChange(json, replacer), workspaceRoot, userHome);
+    if (disabledAllHooks) {
+        return [];
+    }
+    return mapParsedHooks(hookURI, hooks);
+}
+let ClaudePluginFormatAdapter = class ClaudePluginFormatAdapter {
+    constructor(_workspaceContextService) {
+        this._workspaceContextService = _workspaceContextService;
+        this.format = AgentPluginFormat.Claude;
+        this.manifestPath = ".claude-plugin/plugin.json";
+        this.hookConfigPath = "hooks/hooks.json";
+        this.pluginRootToken = "${CLAUDE_PLUGIN_ROOT}";
+        this.pluginRootEnvVar = "CLAUDE_PLUGIN_ROOT";
+    }
+    parseHooks(hookURI, json, pluginUri, userHome) {
+        return parsePluginRootHooks(
+            hookURI,
+            json,
+            pluginUri,
+            userHome,
+            this._workspaceContextService,
+            "${CLAUDE_PLUGIN_ROOT}",
+            "CLAUDE_PLUGIN_ROOT"
+        );
     }
 };
 ClaudePluginFormatAdapter = ( __decorate([( __param(0, IWorkspaceContextService))], ClaudePluginFormatAdapter));
+let OpenPluginFormatAdapter = class OpenPluginFormatAdapter {
+    constructor(_workspaceContextService) {
+        this._workspaceContextService = _workspaceContextService;
+        this.format = AgentPluginFormat.OpenPlugin;
+        this.manifestPath = ".plugin/plugin.json";
+        this.hookConfigPath = "hooks/hooks.json";
+        this.pluginRootToken = "${PLUGIN_ROOT}";
+        this.pluginRootEnvVar = "PLUGIN_ROOT";
+    }
+    parseHooks(hookURI, json, pluginUri, userHome) {
+        return parsePluginRootHooks(
+            hookURI,
+            json,
+            pluginUri,
+            userHome,
+            this._workspaceContextService,
+            "${PLUGIN_ROOT}",
+            "PLUGIN_ROOT"
+        );
+    }
+};
+OpenPluginFormatAdapter = ( __decorate([( __param(0, IWorkspaceContextService))], OpenPluginFormatAdapter));
+const emptyComponentPathConfig = {
+    paths: [],
+    exclusive: false
+};
+function parseComponentPathConfig(raw) {
+    if (raw === undefined || raw === null) {
+        return emptyComponentPathConfig;
+    }
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        return trimmed ? {
+            paths: [trimmed],
+            exclusive: false
+        } : emptyComponentPathConfig;
+    }
+    if (Array.isArray(raw)) {
+        const paths = ( raw.filter(v => typeof v === "string").map(v => v.trim())).filter(v => v.length > 0);
+        return {
+            paths,
+            exclusive: false
+        };
+    }
+    if (typeof raw === "object") {
+        const obj = raw;
+        if (Array.isArray(obj["paths"])) {
+            const paths = ( obj["paths"].filter(v => typeof v === "string").map(v => v.trim())).filter(v => v.length > 0);
+            const exclusive = obj["exclusive"] === true;
+            return {
+                paths,
+                exclusive
+            };
+        }
+    }
+    return emptyComponentPathConfig;
+}
+function resolveComponentDirs(pluginUri, defaultDir, config) {
+    const dirs = [];
+    if (!config.exclusive) {
+        dirs.push(joinPath(pluginUri, defaultDir));
+    }
+    for (const p of config.paths) {
+        const resolved = normalizePath(joinPath(pluginUri, p));
+        if (isEqualOrParent(resolved, pluginUri)) {
+            dirs.push(resolved);
+        }
+    }
+    return dirs;
+}
 let AgentPluginService = class AgentPluginService extends Disposable {
-    constructor(instantiationService, configurationService) {
+    constructor(instantiationService, configurationService, storageService) {
         super();
+        this.enablementModel = this._register(( new EnablementModel("agentPlugins.enablement", storageService)));
         const pluginsEnabled = observableConfigValue(ChatConfiguration.PluginsEnabled, true, configurationService);
         const discoveries = [];
         for (const descriptor of agentPluginDiscoveryRegistry.getAll()) {
             const discovery = instantiationService.createInstance(descriptor);
             this._register(discovery);
             discoveries.push(discovery);
-            discovery.start();
+            discovery.start(this.enablementModel);
         }
-        this.allPlugins = derived(read => {
+        this.plugins = derived(read => {
             if (!pluginsEnabled.read(read)) {
                 return [];
             }
             return this._dedupeAndSort(discoveries.flatMap(d => d.plugins.read(read)));
         });
-        this.plugins = derived(reader => {
-            const all = this.allPlugins.read(reader);
-            return all.filter(p => p.enabled.read(reader));
-        });
-    }
-    setPluginEnabled(pluginUri, enabled) {
-        const plugin = this.allPlugins.get().find(p => ( p.uri.toString()) === ( pluginUri.toString()));
-        if (plugin) {
-            plugin.setEnabled(enabled);
-        }
     }
     _dedupeAndSort(plugins) {
         const unique = [];
@@ -182,7 +315,7 @@ let AgentPluginService = class AgentPluginService extends Disposable {
         return unique;
     }
 };
-AgentPluginService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationService))], AgentPluginService));
+AgentPluginService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationService)), ( __param(2, IStorageService))], AgentPluginService));
 class AbstractAgentPluginDiscovery extends Disposable {
     constructor(_fileService, _pathService, _logService, _instantiationService) {
         super();
@@ -212,14 +345,9 @@ class AbstractAgentPluginDiscovery extends Disposable {
             if (!( seenPluginUris.has(key))) {
                 seenPluginUris.add(key);
                 const adapter = await this._detectPluginFormatAdapter(source.uri);
-                plugins.push(this._toPlugin(
-                    source.uri,
-                    source.enabled,
-                    adapter,
-                    source.fromMarketplace,
-                    value => source.setEnabled(value),
-                    () => source.remove()
-                ));
+                plugins.push(
+                    this._toPlugin(source.uri, adapter, source.fromMarketplace, () => source.remove())
+                );
             }
         }
         this._disposePluginEntriesExcept(seenPluginUris);
@@ -227,6 +355,9 @@ class AbstractAgentPluginDiscovery extends Disposable {
         return plugins;
     }
     async _detectPluginFormatAdapter(pluginUri) {
+        if (await this._pathExists(joinPath(pluginUri, ".plugin", "plugin.json"))) {
+            return this._instantiationService.createInstance(OpenPluginFormatAdapter);
+        }
         const isInClaudeDirectory = pluginUri.path.split("/").includes(".claude");
         if (isInClaudeDirectory || (await this._pathExists(joinPath(pluginUri, ".claude-plugin", "plugin.json")))) {
             return this._instantiationService.createInstance(ClaudePluginFormatAdapter);
@@ -241,14 +372,7 @@ class AbstractAgentPluginDiscovery extends Disposable {
             return false;
         }
     }
-    _toPlugin(
-        uri,
-        initialEnabled,
-        adapter,
-        fromMarketplace,
-        setEnabledCallback,
-        removeCallback
-    ) {
+    _toPlugin(uri, adapter, fromMarketplace, removeCallback) {
         const key = ( uri.toString());
         const existing = this._pluginEntries.get(key);
         if (existing) {
@@ -256,72 +380,99 @@ class AbstractAgentPluginDiscovery extends Disposable {
                 existing.store.dispose();
                 this._pluginEntries.delete(key);
             } else {
-                existing.plugin.enabled.set(initialEnabled, undefined);
                 return existing.plugin;
             }
         }
         const store = ( new DisposableStore());
-        const commands = observableValue("agentPluginCommands", []);
-        const skills = observableValue("agentPluginSkills", []);
-        const agents = observableValue("agentPluginAgents", []);
-        const hooks = observableValue("agentPluginHooks", []);
-        const mcpServerDefinitions = observableValue("agentPluginMcpServerDefinitions", []);
-        const enabled = observableValue("agentPluginEnabled", initialEnabled);
-        const commandsDir = joinPath(uri, "commands");
-        const skillsDir = joinPath(uri, "skills");
-        const agentsDir = joinPath(uri, "agents");
-        const commandsScheduler = store.add(( new RunOnceScheduler(async () => {
-            commands.set(await this._readCommands(uri), undefined);
-        }, 200)));
-        const skillsScheduler = store.add(( new RunOnceScheduler(async () => {
-            skills.set(await this._readSkills(uri), undefined);
-        }, 200)));
-        const agentsScheduler = store.add(( new RunOnceScheduler(async () => {
-            agents.set(await this._readAgents(uri), undefined);
-        }, 200)));
-        const hooksScheduler = store.add(( new RunOnceScheduler(async () => {
-            hooks.set(await this._readHooks(uri, adapter), undefined);
-        }, 200)));
-        const mcpScheduler = store.add(( new RunOnceScheduler(async () => {
-            mcpServerDefinitions.set(await this._readMcpDefinitions(uri, adapter), undefined);
-        }, 200)));
-        store.add(this._fileService.watch(uri, {
-            recursive: true,
+        const enablement = derived(r => this._enablementModel.readEnabled(key, r));
+        const manifest = observableValue("agentPluginManifest", undefined);
+        const observeComponent = (prop, doRead, tryReadEmbedded, defaultPath = prop) => {
+            const secondObs = derivedOpts({
+                equalsFn: equals
+            }, reader => manifest.read(reader)?.[prop]);
+            const wrapped = derived(reader => {
+                const section = secondObs.read(reader);
+                if (tryReadEmbedded) {
+                    if (section && typeof section === "object" && !Array.isArray(section) && !(hasKey(section, {
+                        paths: true
+                    }))) {
+                        return {
+                            kind: "const",
+                            data: ( new ObservablePromise(tryReadEmbedded(section)))
+                        };
+                    }
+                }
+                const paths = parseComponentPathConfig(section);
+                const dirs = resolveComponentDirs(uri, defaultPath, paths);
+                for (const d of dirs) {
+                    const watcher = this._fileService.createWatcher(d, {
+                        recursive: false,
+                        excludes: []
+                    });
+                    reader.store.add(watcher);
+                    reader.store.add(watcher.onDidChange(() => changeTrigger.trigger(undefined)));
+                }
+                return {
+                    kind: "dirs",
+                    dirs: dirs
+                };
+            });
+            const changeTrigger = observableSignal("fileChange");
+            const promised = derived(reader => {
+                const w = wrapped.read(reader);
+                if (w.kind === "const") {
+                    return w.data.promiseResult;
+                } else {
+                    changeTrigger.read(reader);
+                    const promise = ( new ObservablePromise(doRead(w.dirs)));
+                    return promise.promiseResult;
+                }
+            });
+            const result = ( promised.map((w, r) => w.read(r)?.data ?? Iterable.empty()));
+            return result.recomputeInitiallyAndOnChange(store);
+        };
+        const manifestUri = joinPath(uri, adapter.manifestPath);
+        const commands = observeComponent("commands", d => this._readMarkdownComponents(d));
+        const skills = observeComponent("skills", d => this._readSkills(uri, d));
+        const agents = observeComponent("agents", d => this._readMarkdownComponents(d));
+        const instructions = observeComponent("rules", d => this._readRules(d));
+        const hooks = observeComponent(
+            "hooks",
+            paths => this._readHooksFromPaths(uri, paths, adapter),
+            async section => {
+                const userHome = (await this._pathService.userHome()).fsPath;
+                return adapter.parseHooks(manifestUri, section, uri, userHome);
+            },
+            adapter.hookConfigPath
+        );
+        const mcpServerDefinitions = observeComponent(
+            "mcpServers",
+            paths => this._readMcpDefinitionsFromPaths(paths, uri.fsPath, adapter),
+            async section => this._parseMcpServerDefinitionMap(manifestUri, {
+                mcpServers: section
+            }, uri.fsPath, adapter),
+            ".mcp.json"
+        );
+        const readManifest = async () => {
+            manifest.set(await this._readManifest(uri, adapter), undefined);
+        };
+        const manifestWatcher = this._fileService.createWatcher(manifestUri, {
+            recursive: false,
             excludes: []
-        }));
-        store.add(this._fileService.onDidFilesChange(e => {
-            if (e.affects(commandsDir)) {
-                commandsScheduler.schedule();
-            }
-            if (e.affects(skillsDir)) {
-                skillsScheduler.schedule();
-            }
-            if (e.affects(agentsDir)) {
-                agentsScheduler.schedule();
-            }
-            if (( adapter.hookWatchPaths.some(path => e.affects(joinPath(uri, path))))) {
-                hooksScheduler.schedule();
-            }
-            if (e.affects(joinPath(uri, ".mcp.json")) || ( adapter.manifestPaths.some(path => e.affects(joinPath(uri, path))))) {
-                mcpScheduler.schedule();
-                hooksScheduler.schedule();
-            }
-        }));
-        commandsScheduler.schedule();
-        skillsScheduler.schedule();
-        agentsScheduler.schedule();
-        hooksScheduler.schedule();
-        mcpScheduler.schedule();
+        });
+        store.add(manifestWatcher);
+        store.add(manifestWatcher.onDidChange(() => readManifest()));
+        readManifest();
         const plugin = {
             uri,
             label: fromMarketplace?.name ?? basename(uri),
-            enabled,
-            setEnabled: setEnabledCallback,
+            enablement,
             remove: removeCallback,
             hooks,
             commands,
             skills,
             agents,
+            instructions,
             mcpServerDefinitions,
             fromMarketplace
         };
@@ -332,53 +483,59 @@ class AbstractAgentPluginDiscovery extends Disposable {
         });
         return plugin;
     }
-    async _readMcpDefinitions(pluginUri, adapter) {
-        const mcpUri = joinPath(pluginUri, ".mcp.json");
-        const mcpFileConfig = await this._readJsonFile(mcpUri);
-        const fileDefinitions = this._parseMcpServerDefinitionMap(mcpFileConfig);
-        const pluginJsonDefinitions = await this._readInlinePluginJsonMcpDefinitions(pluginUri, adapter);
-        const merged = ( new Map());
-        for (const definition of fileDefinitions) {
-            merged.set(definition.name, definition.configuration);
+    async _readManifest(pluginUri, adapter) {
+        const json = await this._readJsonFile(joinPath(pluginUri, adapter.manifestPath));
+        if (json && typeof json === "object") {
+            return json;
         }
-        for (const definition of pluginJsonDefinitions) {
-            if (!( merged.has(definition.name))) {
-                merged.set(definition.name, definition.configuration);
+        return undefined;
+    }
+    async _readHooksFromPaths(pluginUri, paths, adapter) {
+        const userHome = (await this._pathService.userHome()).fsPath;
+        for (const hookPath of paths) {
+            const json = await this._readJsonFile(hookPath);
+            if (json) {
+                try {
+                    return adapter.parseHooks(hookPath, json, pluginUri, userHome);
+                } catch (e) {
+                    this._logService.info(`[AgentPluginDiscovery] Failed to parse hooks from ${( hookPath.toString())}:`, e);
+                }
             }
         }
-        const definitions = ( [...merged.entries()].map(([name, configuration]) => ({
-            name,
-            configuration
-        }))).sort((a, b) => a.name.localeCompare(b.name));
-        return definitions;
+        return [];
     }
-    async _readInlinePluginJsonMcpDefinitions(pluginUri, adapter) {
-        for (const manifestPath of ( adapter.manifestPaths.map(path => joinPath(pluginUri, path)))) {
-            const manifest = await this._readJsonFile(manifestPath);
-            if (!manifest || typeof manifest !== "object") {
-                continue;
-            }
-            const definitions = this._parseMcpServerDefinitionMap(manifest);
-            if (definitions.length > 0) {
-                return definitions;
+    async _readMcpDefinitionsFromPaths(paths, pluginFsPath, adapter) {
+        const merged = ( new Map());
+        for (const mcpPath of paths) {
+            const json = await this._readJsonFile(mcpPath);
+            for (const def of this._parseMcpServerDefinitionMap(mcpPath, json, pluginFsPath, adapter)) {
+                if (!( merged.has(def.name))) {
+                    merged.set(def.name, def);
+                }
             }
         }
-        return [];
+        return [...( merged.values())].sort((a, b) => a.name.localeCompare(b.name));
     }
-    _parseMcpServerDefinitionMap(raw) {
-        if (!raw || typeof raw !== "object" || !raw.hasOwnProperty("mcpServers")) {
+    _parseMcpServerDefinitionMap(definitionURI, raw, pluginFsPath, adapter) {
+        const mcpServers = resolveMcpServersMap(raw);
+        if (!mcpServers) {
             return [];
         }
         const definitions = [];
-        for (const [name, configValue] of Object.entries(raw.mcpServers)) {
+        for (const [name, configValue] of Object.entries(mcpServers)) {
             const configuration = this._normalizeMcpServerConfiguration(configValue);
             if (!configuration) {
                 continue;
             }
-            definitions.push({
+            let def = {
                 name,
-                configuration
-            });
+                configuration,
+                uri: definitionURI
+            };
+            if (adapter.pluginRootToken && adapter.pluginRootEnvVar) {
+                def = interpolateMcpPluginRoot(def, pluginFsPath, adapter.pluginRootToken, adapter.pluginRootEnvVar);
+            }
+            definitions.push(def);
         }
         return definitions;
     }
@@ -428,41 +585,6 @@ class AbstractAgentPluginDiscovery extends Disposable {
         }
         return undefined;
     }
-    async _readHooks(pluginUri, adapter) {
-        const userHome = (await this._pathService.userHome()).fsPath;
-        for (const hooksUri of ( adapter.hookConfigPaths.map(path => joinPath(pluginUri, path)))) {
-            const json = await this._readJsonFile(hooksUri);
-            if (json) {
-                try {
-                    return adapter.parseHooks(json, pluginUri, userHome);
-                } catch (e) {
-                    this._logService.info(
-                        `[ConfiguredAgentPluginDiscovery] Failed to parse hooks from ${( hooksUri.toString())}:`,
-                        e
-                    );
-                }
-            }
-        }
-        for (const manifestPath of ( adapter.manifestPaths.map(path => joinPath(pluginUri, path)))) {
-            const manifest = await this._readJsonFile(manifestPath);
-            if (manifest && typeof manifest === "object") {
-                const hooks = manifest["hooks"];
-                if (hooks && typeof hooks === "object") {
-                    try {
-                        return adapter.parseHooks({
-                            hooks
-                        }, pluginUri, userHome);
-                    } catch (e) {
-                        this._logService.info(
-                            `[ConfiguredAgentPluginDiscovery] Failed to parse hooks from manifest ${( manifestPath.toString())}:`,
-                            e
-                        );
-                    }
-                }
-            }
-        }
-        return [];
-    }
     async _readJsonFile(uri) {
         try {
             const fileContents = await this._fileService.readFile(uri);
@@ -471,80 +593,133 @@ class AbstractAgentPluginDiscovery extends Disposable {
             return undefined;
         }
     }
-    async _readSkills(uri) {
-        const skillsDir = joinPath(uri, "skills");
-        let stat;
-        try {
-            stat = await this._fileService.resolve(skillsDir);
-        } catch {
-            return [];
-        }
-        if (!stat.isDirectory || !stat.children) {
-            return [];
-        }
+    async _readSkills(pluginRoot, dirs) {
+        const seen = ( new Set());
         const skills = [];
-        for (const child of stat.children) {
-            const skillMd = URI.joinPath(child.resource, "SKILL.md");
-            if (!(await this._pathExists(skillMd))) {
+        const addSkill = (name, skillMd) => {
+            if (!( seen.has(name))) {
+                seen.add(name);
+                skills.push({
+                    uri: skillMd,
+                    name
+                });
+            }
+        };
+        for (const dir of dirs) {
+            const skillMd = URI.joinPath(dir, "SKILL.md");
+            if (await this._pathExists(skillMd)) {
+                addSkill(basename(dir), skillMd);
                 continue;
             }
-            skills.push({
-                uri: skillMd,
-                name: basename(child.resource)
-            });
+            let stat;
+            try {
+                stat = await this._fileService.resolve(dir);
+            } catch {
+                continue;
+            }
+            if (!stat.isDirectory || !stat.children) {
+                continue;
+            }
+            for (const child of stat.children) {
+                const childSkillMd = URI.joinPath(child.resource, "SKILL.md");
+                if (await this._pathExists(childSkillMd)) {
+                    addSkill(basename(child.resource), childSkillMd);
+                }
+            }
+        }
+        if (skills.length === 0) {
+            const rootSkillMd = URI.joinPath(pluginRoot, "SKILL.md");
+            if (await this._pathExists(rootSkillMd)) {
+                addSkill(basename(pluginRoot), rootSkillMd);
+            }
         }
         skills.sort((a, b) => a.name.localeCompare(b.name));
         return skills;
     }
-    async _readAgents(uri) {
-        const agentsDir = joinPath(uri, "agents");
-        let stat;
-        try {
-            stat = await this._fileService.resolve(agentsDir);
-        } catch {
-            return [];
-        }
-        if (!stat.isDirectory || !stat.children) {
-            return [];
-        }
-        const agents = [];
-        for (const child of stat.children) {
-            if (!child.isFile || extname(child.resource).toLowerCase() !== COMMAND_FILE_SUFFIX) {
+    async _readRules(dirs) {
+        const seen = ( new Set());
+        const items = [];
+        const matchSuffix = filename => {
+            const lower = filename.toLowerCase();
+            return RULE_FILE_SUFFIXES.find(s => lower.endsWith(s));
+        };
+        const addItem = (name, uri) => {
+            if (!( seen.has(name))) {
+                seen.add(name);
+                items.push({
+                    uri,
+                    name
+                });
+            }
+        };
+        for (const dir of dirs) {
+            let stat;
+            try {
+                stat = await this._fileService.resolve(dir);
+            } catch {
                 continue;
             }
-            const name = basename(child.resource).slice(0, -COMMAND_FILE_SUFFIX.length);
-            agents.push({
-                uri: child.resource,
-                name
-            });
-        }
-        agents.sort((a, b) => a.name.localeCompare(b.name));
-        return agents;
-    }
-    async _readCommands(uri) {
-        const commandsDir = joinPath(uri, "commands");
-        let stat;
-        try {
-            stat = await this._fileService.resolve(commandsDir);
-        } catch {
-            return [];
-        }
-        if (!stat.isDirectory || !stat.children) {
-            return [];
+            if (stat.isFile) {
+                const suffix = matchSuffix(basename(dir));
+                if (suffix) {
+                    addItem(basename(dir).slice(0, -suffix.length), dir);
+                }
+                continue;
+            }
+            if (!stat.isDirectory || !stat.children) {
+                continue;
+            }
+            for (const child of stat.children) {
+                if (!child.isFile) {
+                    continue;
+                }
+                const suffix = matchSuffix(child.name);
+                if (suffix) {
+                    addItem(child.name.slice(0, -suffix.length), child.resource);
+                }
+            }
         }
-        const commands = [];
-        for (const child of stat.children) {
-            if (!child.isFile || extname(child.resource).toLowerCase() !== COMMAND_FILE_SUFFIX) {
+        items.sort((a, b) => a.name.localeCompare(b.name));
+        return items;
+    }
+    async _readMarkdownComponents(dirs) {
+        const seen = ( new Set());
+        const items = [];
+        const addItem = (name, uri) => {
+            if (!( seen.has(name))) {
+                seen.add(name);
+                items.push({
+                    uri,
+                    name
+                });
+            }
+        };
+        for (const dir of dirs) {
+            let stat;
+            try {
+                stat = await this._fileService.resolve(dir);
+            } catch {
                 continue;
             }
-            const name = basename(child.resource).slice(0, -COMMAND_FILE_SUFFIX.length);
-            commands.push({
-                uri: child.resource,
-                name
-            });
+            if (stat.isFile && extname(dir).toLowerCase() === COMMAND_FILE_SUFFIX) {
+                addItem(basename(dir).slice(0, -COMMAND_FILE_SUFFIX.length), dir);
+                continue;
+            }
+            if (!stat.isDirectory || !stat.children) {
+                continue;
+            }
+            for (const child of stat.children) {
+                if (!child.isFile || extname(child.resource).toLowerCase() !== COMMAND_FILE_SUFFIX) {
+                    continue;
+                }
+                addItem(
+                    basename(child.resource).slice(0, -COMMAND_FILE_SUFFIX.length),
+                    child.resource
+                );
+            }
         }
-        commands.sort((a, b) => a.name.localeCompare(b.name));
-        return commands;
+        items.sort((a, b) => a.name.localeCompare(b.name));
+        return items;
     }
     _disposePluginEntriesExcept(keep) {
         for (const [key, entry] of this._pluginEntries) {
@@ -575,7 +750,8 @@ let ConfiguredAgentPluginDiscovery = class ConfiguredAgentPluginDiscovery extend
         this._workspaceContextService = _workspaceContextService;
         this._pluginLocationsConfig = observableConfigValue(ChatConfiguration.PluginLocations, {}, _configurationService);
     }
-    start() {
+    start(enablementModel) {
+        this._enablementModel = enablementModel;
         const scheduler = this._register(( new RunOnceScheduler(() => this._refreshPlugins(), 0)));
         this._register(autorun(reader => {
             this._pluginLocationsConfig.read(reader);
@@ -588,7 +764,7 @@ let ConfiguredAgentPluginDiscovery = class ConfiguredAgentPluginDiscovery extend
         const config = this._pluginLocationsConfig.get();
         const userHome = await this._getUserHome();
         for (const [path, enabled] of Object.entries(config)) {
-            if (!path.trim()) {
+            if (!path.trim() || enabled === false) {
                 continue;
             }
             const resources = this._resolvePluginPath(path.trim(), userHome);
@@ -612,9 +788,7 @@ let ConfiguredAgentPluginDiscovery = class ConfiguredAgentPluginDiscovery extend
                 const configKey = path;
                 sources.push({
                     uri: stat.resource,
-                    enabled,
                     fromMarketplace,
-                    setEnabled: value => this._updatePluginPathEnabled(configKey, value),
                     remove: () => this._removePluginPath(configKey)
                 });
             }
@@ -634,32 +808,6 @@ let ConfiguredAgentPluginDiscovery = class ConfiguredAgentPluginDiscovery extend
         }
         return ( this._workspaceContextService.getWorkspace().folders.map(folder => joinPath(folder.uri, path)));
     }
-    _updatePluginPathEnabled(configKey, value) {
-        const inspected = this._configurationService.inspect(ChatConfiguration.PluginLocations);
-        const targets = [
-            ConfigurationTarget.WORKSPACE_FOLDER,
-            ConfigurationTarget.WORKSPACE,
-            ConfigurationTarget.USER_LOCAL,
-            ConfigurationTarget.USER_REMOTE,
-            ConfigurationTarget.USER,
-            ConfigurationTarget.APPLICATION
-        ];
-        for (const target of targets) {
-            const mapping = getConfigValueInTarget(inspected, target);
-            if (mapping && Object.prototype.hasOwnProperty.call(mapping, configKey)) {
-                this._configurationService.updateValue(ChatConfiguration.PluginLocations, {
-                    ...mapping,
-                    [configKey]: value
-                }, target);
-                return;
-            }
-        }
-        const current = getConfigValueInTarget(inspected, ConfigurationTarget.USER_LOCAL) ?? {};
-        this._configurationService.updateValue(ChatConfiguration.PluginLocations, {
-            ...current,
-            [configKey]: value
-        }, ConfigurationTarget.USER_LOCAL);
-    }
     _removePluginPath(configKey) {
         const inspected = this._configurationService.inspect(ChatConfiguration.PluginLocations);
         const targets = [
@@ -697,7 +845,8 @@ let MarketplaceAgentPluginDiscovery = class MarketplaceAgentPluginDiscovery exte
         this._pluginMarketplaceService = _pluginMarketplaceService;
         this._pluginRepositoryService = _pluginRepositoryService;
     }
-    start() {
+    start(enablementModel) {
+        this._enablementModel = enablementModel;
         const scheduler = this._register(( new RunOnceScheduler(() => this._refreshPlugins(), 0)));
         this._register(autorun(reader => {
             this._pluginMarketplaceService.installedPlugins.read(reader);
@@ -726,12 +875,12 @@ let MarketplaceAgentPluginDiscovery = class MarketplaceAgentPluginDiscovery exte
             }
             sources.push({
                 uri: stat.resource,
-                enabled: entry.enabled,
                 fromMarketplace: entry.plugin,
-                setEnabled: value => this._pluginMarketplaceService.setInstalledPluginEnabled(entry.pluginUri, value),
                 remove: () => {
+                    this._enablementModel.remove(( stat.resource.toString()));
                     this._pluginMarketplaceService.removeInstalledPlugin(entry.pluginUri);
-                    this._pluginRepositoryService.cleanupPluginSource(entry.plugin).catch(error => {
+                    const remaining = this._pluginMarketplaceService.installedPlugins.get();
+                    this._pluginRepositoryService.cleanupPluginSource(entry.plugin, ( remaining.map(e => e.plugin.sourceDescriptor))).catch(error => {
                         this._logService.error(
                             "[MarketplaceAgentPluginDiscovery] Failed to clean up plugin source",
                             error
@@ -745,4 +894,4 @@ let MarketplaceAgentPluginDiscovery = class MarketplaceAgentPluginDiscovery exte
 };
 MarketplaceAgentPluginDiscovery = ( __decorate([( __param(0, IPluginMarketplaceService)), ( __param(1, IAgentPluginRepositoryService)), ( __param(2, IFileService)), ( __param(3, IPathService)), ( __param(4, ILogService)), ( __param(5, IInstantiationService))], MarketplaceAgentPluginDiscovery));
 
-export { AbstractAgentPluginDiscovery, AgentPluginService, ConfiguredAgentPluginDiscovery, MarketplaceAgentPluginDiscovery, shellQuotePluginRootInCommand };
+export { AbstractAgentPluginDiscovery, AgentPluginService, ConfiguredAgentPluginDiscovery, MarketplaceAgentPluginDiscovery, resolveMcpServersMap, shellQuotePluginRootInCommand };