wave-agent-sdk 1.1.5 → 1.3.0

package/dist/managers/pluginManager.js

@@ -4,10 +4,27 @@ import * as path from "path";
 import { existsSync, readdirSync } from "fs";
 import { getBuiltinPluginsDir } from "../utils/configPaths.js";
 import { MarketplaceService } from "../services/MarketplaceService.js";
+import { DEFAULT_PLUGIN_VERSION } from "../constants/plugins.js";
 export class PluginManager {
+    serialize(task) {
+        const result = this.loadChain.then(task, task);
+        // Keep the chain alive after a failure so later reloads still run.
+        this.loadChain = result.then(() => undefined, () => undefined);
+        return result;
+    }
     constructor(container, options) {
         this.container = container;
         this.plugins = new Map();
+        /** Explicit configs from the last load, replayed by reloadAllPlugins(). */
+        this.lastLoadConfigs = [];
+        /** Failures collected by the current loadPlugins() run. */
+        this.loadFailures = [];
+        /**
+         * Serializes plugin (re)loads. A managed-settings sync (or an early
+         * `/reload-plugins`) can ask for a reload while the startup load is still
+         * running; interleaving them would leave half-unloaded capability registries.
+         */
+        this.loadChain = Promise.resolve();
         this.workdir = options.workdir;
         this.enabledPlugins = options.enabledPlugins || {};
     }
@@ -51,12 +68,6 @@ export class PluginManager {
                 this.enabledPlugins = this.configurationService.getMergedEnabledPlugins(this.workdir);
             }
             const marketplaceService = new MarketplaceService(this.workdir, this.configurationService);
-            // Trigger auto-update for marketplaces in the background
-            if (!process.env.VITEST) {
-                marketplaceService.autoUpdateAll().catch((error) => {
-                    logger?.error("Background marketplace auto-update failed:", error);
-                });
-            }
             let installedRegistry = await marketplaceService.getInstalledPlugins();
             const knownMarketplaces = await marketplaceService.listMarketplaces();
             // Identify missing enabled plugins and auto-install them if marketplace is known
@@ -74,7 +85,7 @@ export class PluginManager {
                     const isMarketplaceKnown = knownMarketplaces.some((m) => m.name === marketplaceName);
                     if (isMarketplaceKnown) {
                         // Pre-check: verify the plugin still exists in the marketplace manifest
-                        // before acquiring the lock in installPlugin (which can block ~8s during autoUpdate)
+                        // before acquiring the lock in installPlugin (which can block ~8s during a marketplace refresh)
                         const marketplace = knownMarketplaces.find((m) => m.name === marketplaceName);
                         if (!marketplace)
                             continue;
@@ -119,12 +130,18 @@ export class PluginManager {
             }
             // Refresh registry after potential auto-installs
             installedRegistry = await marketplaceService.getInstalledPlugins();
+            // 同一插件在本机可能有多条安装记录（各作用域/各项目各一条，spec plugin
+            // A-015）；按插件去重，否则同一个 cachePath 会被加载多次。
+            const loaded = new Set();
             for (const p of installedRegistry.plugins) {
                 const pluginId = `${p.name}@${p.marketplace}`;
                 if (this.enabledPlugins[pluginId] !== true) {
                     logger?.debug(`Plugin ${pluginId} is not enabled via configuration`);
                     continue;
                 }
+                if (loaded.has(pluginId))
+                    continue;
+                loaded.add(pluginId);
                 await this.loadSinglePlugin(p.cachePath);
             }
         }
@@ -145,12 +162,15 @@ export class PluginManager {
             }
             const plugin = {
                 ...manifest,
+                // A manifest without `version` is legal (spec plugin A-022); the default
+                // matches what the install path files under `installed_plugins.json`.
+                version: manifest.version || DEFAULT_PLUGIN_VERSION,
                 path: absolutePath,
                 commands: PluginLoader.loadCommands(absolutePath),
                 skills: await PluginLoader.loadSkills(absolutePath),
                 agents: await PluginLoader.loadAgents(absolutePath),
                 lspConfig: await PluginLoader.loadLspConfig(absolutePath),
-                mcpConfig: await PluginLoader.loadMcpConfig(absolutePath),
+                mcpConfig: await PluginLoader.loadMcpConfig(absolutePath, manifest.mcpServers),
                 hooksConfig: await PluginLoader.loadHooksConfig(absolutePath),
             };
             // Register components with managers
@@ -168,8 +188,15 @@ export class PluginManager {
             }
             if (this.mcpManager && plugin.mcpConfig) {
                 for (const [name, config] of Object.entries(plugin.mcpConfig.mcpServers)) {
-                    const configWithPluginRoot = { ...config, pluginRoot: plugin.path };
-                    this.mcpManager.addServer(name, configWithPluginRoot);
+                    // One unusable server declaration must not take the rest of the plugin
+                    // down with it (spec plugin A-023).
+                    try {
+                        const configWithPluginRoot = { ...config, pluginRoot: plugin.path };
+                        this.mcpManager.addServer(name, configWithPluginRoot);
+                    }
+                    catch (error) {
+                        logger?.warn(`Failed to register MCP server '${name}' from plugin ${plugin.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
                 }
             }
             if (this.hookManager && plugin.hooksConfig) {
@@ -179,17 +206,31 @@ export class PluginManager {
                 this.subagentManager.registerPluginAgents(plugin.name, plugin.agents);
             }
             this.plugins.set(manifest.name, plugin);
-            logger?.debug(`Loaded plugin: ${manifest.name} v${manifest.version}`);
+            logger?.debug(`Loaded plugin: ${manifest.name} v${plugin.version}`);
         }
         catch (error) {
+            this.loadFailures.push({
+                path: absolutePath,
+                error: error instanceof Error ? error.message : String(error),
+            });
             logger?.error(`Failed to load plugin from ${absolutePath}`, error);
         }
     }
     /**
      * Load plugins from configuration
      * @param configs Array of plugin configurations
+     * @returns the plugins that failed to load
      */
     async loadPlugins(configs) {
+        return this.serialize(() => this.doLoadPlugins(configs));
+    }
+    /**
+     * The actual load. Reached through [loadPlugins] (which serializes concurrent
+     * requests) and directly from [reloadAllPlugins], which already holds the slot.
+     */
+    async doLoadPlugins(configs) {
+        this.lastLoadConfigs = configs;
+        this.loadFailures = [];
         // Load plugins from configuration (e.g. --plugin-dir) first to give them higher priority
         for (const config of configs) {
             if (config.type !== "local") {
@@ -205,6 +246,71 @@ export class PluginManager {
         await this.loadInstalledPlugins();
         // Load built-in plugins bundled with the SDK (lowest priority)
         await this.loadBuiltinPlugins();
+        return [...this.loadFailures];
+    }
+    /**
+     * Unload a single plugin: drop everything it contributed from the six
+     * capability registries, then forget it. Other plugins and the running
+     * session are untouched.
+     * @returns true if the plugin was loaded
+     */
+    async unloadPlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            return false;
+        }
+        // Managers key their entries off the plugin name (commands/skills/agents)
+        // or the plugin root path (hooks/LSP/MCP), so each needs its own removal.
+        this.slashCommandManager?.unregisterPluginCommands(plugin.name);
+        this.skillManager?.unregisterPluginSkills(plugin.name);
+        this.subagentManager?.unregisterPluginAgents(plugin.name);
+        this.hookManager?.unregisterPluginHooks(plugin.path);
+        await this.lspManager?.unregisterServersForPlugin(plugin.path);
+        this.mcpManager?.removeServersForPlugin(plugin.path);
+        // Revoke the builtin helper-script grants this plugin added, so disabling
+        // it does not leave a standing permission behind.
+        for (const rule of PluginManager.BUILTIN_PLUGIN_ALLOW_RULES[plugin.name] ||
+            []) {
+            this.permissionManager?.removeInstanceAllowedRule(rule);
+        }
+        this.plugins.delete(name);
+        logger?.debug(`Unloaded plugin: ${name}`);
+        return true;
+    }
+    /**
+     * Re-read every plugin in place — the `/reload-plugins` command.
+     *
+     * Unloads everything currently loaded, re-reads `enabledPlugins` from the
+     * configuration chain (so a settings edit is honored), then replays the
+     * original load order (explicit configs → installed → builtin). The session,
+     * transcript and sessionId are untouched; only the capability registries are
+     * swapped, which is what makes this an in-place reload instead of a rebuild.
+     *
+     * Unload must happen before any caller-side mutation of the plugin cache dir:
+     * hooks, MCP, LSP, skills and agents all bake absolute plugin paths at
+     * registration time, so an entry left pointing at a deleted directory is
+     * worse than a merely stale one.
+     */
+    async reloadAllPlugins() {
+        return this.serialize(async () => {
+            for (const name of Array.from(this.plugins.keys())) {
+                await this.unloadPlugin(name);
+            }
+            this.enabledPlugins = this.refreshEnabledPlugins();
+            const failures = await this.doLoadPlugins(this.lastLoadConfigs);
+            return {
+                plugins: Array.from(this.plugins.keys()),
+                failures,
+            };
+        });
+    }
+    /**
+     * Re-read enabled plugins from the merged configuration chain, falling back
+     * to the last known value when the service is unavailable.
+     */
+    refreshEnabledPlugins() {
+        const merged = this.configurationService?.getMergedEnabledPlugins(this.workdir);
+        return merged ?? this.enabledPlugins;
     }
     /**
      * Load built-in plugins bundled with the SDK (e.g. sdd).

package/dist/managers/pluginScopeManager.d.ts

@@ -1,6 +1,6 @@
 import { ConfigurationService } from "../services/configurationService.js";
 import { PluginManager } from "./pluginManager.js";
-import { Logger } from "../types/index.js";
+import { Logger, PluginInstallLocation } from "../types/index.js";
 import { Scope } from "../types/configuration.js";
 export interface PluginScopeManagerOptions {
     workdir: string;
@@ -31,9 +31,22 @@ export declare class PluginScopeManager {
      * Priority: local > project > user
      */
     findPluginScope(pluginId: string): Scope | null;
+    /**
+     * The install location a record for `scope` is keyed by (spec plugin A-015):
+     * 用户作用域是本机全局的（不带 projectPath），项目/本地作用域归属当前仓库。
+     */
+    getInstallLocation(scope: Scope): PluginInstallLocation;
+    /**
+     * Remove a plugin's enabled record from a single scope, leaving every other
+     * scope (including other projects' project/local records) untouched — the
+     * uninstall semantics of spec plugin A-015. Use [removePluginFromAllScopes]
+     * only for 「更换安装作用域」.
+     */
+    removePluginFromScope(scope: Scope, pluginId: string): Promise<void>;
     /**
      * Remove a plugin from all scopes (user, project, local)
-     * This is useful when uninstalling a plugin to clean up all configuration
+     * This is useful when moving a plugin to another scope: the old scope must
+     * not keep the plugin (spec plugin「设置页插件市场」场景 11).
      */
     removePluginFromAllScopes(pluginId: string): Promise<void>;
     /**

package/dist/managers/pluginScopeManager.js

@@ -56,9 +56,28 @@ export class PluginScopeManager {
         }
         return null;
     }
+    /**
+     * The install location a record for `scope` is keyed by (spec plugin A-015):
+     * 用户作用域是本机全局的（不带 projectPath），项目/本地作用域归属当前仓库。
+     */
+    getInstallLocation(scope) {
+        return scope === "user" ? { scope } : { scope, projectPath: this.workdir };
+    }
+    /**
+     * Remove a plugin's enabled record from a single scope, leaving every other
+     * scope (including other projects' project/local records) untouched — the
+     * uninstall semantics of spec plugin A-015. Use [removePluginFromAllScopes]
+     * only for 「更换安装作用域」.
+     */
+    async removePluginFromScope(scope, pluginId) {
+        await this.configurationService.removeEnabledPlugin(this.workdir, scope, pluginId);
+        this.logger?.info(`Removed plugin ${pluginId} from ${scope} scope`);
+        this.refreshPluginManager();
+    }
     /**
      * Remove a plugin from all scopes (user, project, local)
-     * This is useful when uninstalling a plugin to clean up all configuration
+     * This is useful when moving a plugin to another scope: the old scope must
+     * not keep the plugin (spec plugin「设置页插件市场」场景 11).
      */
     async removePluginFromAllScopes(pluginId) {
         const scopes = ["user", "project", "local"];

package/dist/managers/skillManager.d.ts

@@ -16,6 +16,11 @@ export declare class SkillManager extends EventEmitter {
     private pluginSkillMetadata;
     private pluginSkillContent;
     private initialized;
+    /** Serializes full rescans (initialize / file-watcher events / deleteSkill
+     *  convergence). Overlapping scans over the shared caches must not interleave:
+     *  chaining them keeps the last completed scan in sync with the newest disk
+     *  state instead of letting an older snapshot win a race. */
+    private refreshChain;
     private fileWatcher;
     private watchEnabled;
     constructor(container: Container, options?: SkillManagerOptions);
@@ -27,6 +32,7 @@ export declare class SkillManager extends EventEmitter {
      * Refresh skills by re-discovering them
      */
     private refreshSkills;
+    private performRefresh;
     /**
      * Setup file watcher for skill directories
      */
@@ -97,6 +103,17 @@ export declare class SkillManager extends EventEmitter {
         content: string;
         skill?: undefined;
     }>;
+    /**
+     * Render a skill's body the way the model must see it: frontmatter stripped,
+     * parameters substituted, `${WAVE_SKILL_DIR}` / `${CLAUDE_SKILL_DIR}` /
+     * `${WAVE_PLUGIN_ROOT}` replaced with real paths, and the
+     * `Base directory for this skill: <path>` header prepended.
+     *
+     * Public because the post-compaction re-injection has to render the same
+     * text when it cannot reuse the content recorded at invocation time
+     * (spec core/message-compact 场景 4).
+     */
+    renderSkillContent(skill: Skill, argsString?: string): string;
     /**
      * Prepare skill content with arguments but without bash execution
      */
@@ -113,4 +130,37 @@ export declare class SkillManager extends EventEmitter {
      * Register skills provided by a plugin
      */
     registerPluginSkills(pluginName: string, skills: Skill[]): void;
+    /**
+     * Drop every skill contributed by a plugin, addressed by its plugin name.
+     * Clears the plugin-specific maps too: refreshSkills() re-seeds the visible
+     * maps from them, so clearing only those would resurrect the skills on the
+     * next disk refresh. Called by the in-place plugin reload path before
+     * re-registering.
+     */
+    unregisterPluginSkills(pluginName: string): void;
+    /**
+     * Directory roots that may hold deletable copies of a skill in the given
+     * discovery scope. Personal skills are scanned from three user-level dirs
+     * (~/.wave|~/.claude|~/.agents/skills) and project skills from the current
+     * project's three project dirs (.wave|.claude|.agents/skills). The discovery
+     * map merges same-named copies from these roots into a single name-keyed
+     * entry, so deleteSkill must sweep the whole set to remove a skill fully.
+     */
+    private scopeSkillRoots;
+    /**
+     * Delete a user/personal or project skill by removing its directory
+     * (containing SKILL.md). Builtin and plugin skills are read-only and
+     * cannot be deleted.
+     *
+     * A same-named skill may physically live in several same-scope directories
+     * (~/.wave/skills + ~/.claude/skills + ~/.agents/skills for user skills,
+     * .wave/.claude/.agents/skills under the project for project skills) while
+     * only the highest-priority copy is listed; every copy is removed so one
+     * delete removes the skill completely instead of re-surfacing the next
+     * copy on the next scan. Caches are then re-converged with disk before
+     * returning so the caller's follow-up metadata read reflects the result.
+     * @param name - The skill name as shown in skill metadata
+     * @returns true if the skill was deleted
+     */
+    deleteSkill(name: string): Promise<boolean>;
 }

package/dist/managers/skillManager.js

@@ -1,4 +1,4 @@
-import { readdir, stat } from "fs/promises";
+import { readdir, stat, rm } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
 import { EventEmitter } from "events";
@@ -21,6 +21,11 @@ export class SkillManager extends EventEmitter {
         this.pluginSkillMetadata = new Map();
         this.pluginSkillContent = new Map();
         this.initialized = false;
+        /** Serializes full rescans (initialize / file-watcher events / deleteSkill
+         *  convergence). Overlapping scans over the shared caches must not interleave:
+         *  chaining them keeps the last completed scan in sync with the newest disk
+         *  state instead of letting an older snapshot win a race. */
+        this.refreshChain = Promise.resolve();
         this.fileWatcher = null;
         this.personalSkillsPath =
             options.personalSkillsPath || join(homedir(), ".wave", "skills");
@@ -53,27 +58,52 @@ export class SkillManager extends EventEmitter {
     /**
      * Refresh skills by re-discovering them
      */
-    async refreshSkills() {
-        // Clear only discovered skills (builtin/personal/project), preserve plugin skills
-        this.skillMetadata.clear();
-        this.skillContent.clear();
-        const discovery = await this.discoverSkills();
-        // Store discovered skill metadata
+    refreshSkills() {
+        // Serialize rescans: initialize / file-watcher events / deleteSkill all
+        // trigger full re-scans; running them concurrently makes a stale snapshot
+        // or a partial cache (see performRefresh's atomic swap) observable to
+        // metadata readers such as the settings-page skill list.
+        const run = this.refreshChain.then(() => this.performRefresh());
+        this.refreshChain = run.catch(() => { });
+        return run;
+    }
+    async performRefresh() {
+        // Route this scan's incremental skill-content writes into a scratch map
+        // (processSkillDirs writes to this.skillContent) and rebuild both caches
+        // fully before swapping them in — readers must never observe a
+        // half-refreshed (e.g. momentarily empty) skill list mid-scan.
+        const scratchContent = new Map();
+        const previousContent = this.skillContent;
+        this.skillContent = scratchContent;
+        let discovery;
+        try {
+            discovery = await this.discoverSkills();
+        }
+        catch (error) {
+            this.skillContent = previousContent;
+            throw error;
+        }
+        const nextMetadata = new Map();
+        const nextContent = new Map();
+        // Store discovered skills (builtin/personal/project)
         discovery.builtinSkills.forEach((skill, name) => {
-            this.skillMetadata.set(name, skill);
+            nextMetadata.set(name, skill);
         });
         discovery.personalSkills.forEach((skill, name) => {
-            this.skillMetadata.set(name, skill);
+            nextMetadata.set(name, skill);
         });
         discovery.projectSkills.forEach((skill, name) => {
-            this.skillMetadata.set(name, skill);
+            nextMetadata.set(name, skill);
+        });
+        scratchContent.forEach((skill, name) => {
+            nextContent.set(name, skill);
         });
         // Restore plugin skills
         this.pluginSkillMetadata.forEach((metadata, name) => {
-            this.skillMetadata.set(name, metadata);
+            nextMetadata.set(name, metadata);
         });
         this.pluginSkillContent.forEach((skill, name) => {
-            this.skillContent.set(name, skill);
+            nextContent.set(name, skill);
         });
         // Log any discovery errors
         if (discovery.errors.length > 0) {
@@ -82,6 +112,9 @@ export class SkillManager extends EventEmitter {
                 logger?.warn(`Skill error in ${error.skillPath}: ${error.message}`);
             });
         }
+        // Atomic swap: from this point on readers see the complete new snapshot
+        this.skillMetadata = nextMetadata;
+        this.skillContent = nextContent;
         this.emit("refreshed", Array.from(this.skillMetadata.values()));
     }
     /**
@@ -389,6 +422,19 @@ export class SkillManager extends EventEmitter {
             };
         }
     }
+    /**
+     * Render a skill's body the way the model must see it: frontmatter stripped,
+     * parameters substituted, `${WAVE_SKILL_DIR}` / `${CLAUDE_SKILL_DIR}` /
+     * `${WAVE_PLUGIN_ROOT}` replaced with real paths, and the
+     * `Base directory for this skill: <path>` header prepended.
+     *
+     * Public because the post-compaction re-injection has to render the same
+     * text when it cannot reuse the content recorded at invocation time
+     * (spec core/message-compact 场景 4).
+     */
+    renderSkillContent(skill, argsString = "") {
+        return this.prepareSkillContent(skill, argsString);
+    }
     /**
      * Prepare skill content with arguments but without bash execution
      */
@@ -463,4 +509,112 @@ export class SkillManager extends EventEmitter {
         }
         logger?.debug(`Registered ${skills.length} plugin skills from ${pluginName}. Total skills: ${this.skillMetadata.size}`);
     }
+    /**
+     * Drop every skill contributed by a plugin, addressed by its plugin name.
+     * Clears the plugin-specific maps too: refreshSkills() re-seeds the visible
+     * maps from them, so clearing only those would resurrect the skills on the
+     * next disk refresh. Called by the in-place plugin reload path before
+     * re-registering.
+     */
+    unregisterPluginSkills(pluginName) {
+        const prefix = `${pluginName}:`;
+        for (const name of Array.from(this.pluginSkillMetadata.keys())) {
+            if (name.startsWith(prefix)) {
+                this.pluginSkillMetadata.delete(name);
+            }
+        }
+        for (const name of Array.from(this.pluginSkillContent.keys())) {
+            if (name.startsWith(prefix)) {
+                this.pluginSkillContent.delete(name);
+            }
+        }
+        for (const name of Array.from(this.skillMetadata.keys())) {
+            if (name.startsWith(prefix)) {
+                this.skillMetadata.delete(name);
+            }
+        }
+        for (const name of Array.from(this.skillContent.keys())) {
+            if (name.startsWith(prefix)) {
+                this.skillContent.delete(name);
+            }
+        }
+        logger?.debug(`Unregistered plugin skills from ${pluginName}`);
+    }
+    /**
+     * Directory roots that may hold deletable copies of a skill in the given
+     * discovery scope. Personal skills are scanned from three user-level dirs
+     * (~/.wave|~/.claude|~/.agents/skills) and project skills from the current
+     * project's three project dirs (.wave|.claude|.agents/skills). The discovery
+     * map merges same-named copies from these roots into a single name-keyed
+     * entry, so deleteSkill must sweep the whole set to remove a skill fully.
+     */
+    scopeSkillRoots(type) {
+        if (type === "personal") {
+            return [
+                this.personalSkillsPath,
+                this.personalClaudeSkillsPath,
+                this.personalAgentsSkillsPath,
+            ];
+        }
+        if (type === "project") {
+            return [
+                join(this.workdir, ".wave", "skills"),
+                join(this.workdir, ".claude", "skills"),
+                join(this.workdir, ".agents", "skills"),
+            ];
+        }
+        return [];
+    }
+    /**
+     * Delete a user/personal or project skill by removing its directory
+     * (containing SKILL.md). Builtin and plugin skills are read-only and
+     * cannot be deleted.
+     *
+     * A same-named skill may physically live in several same-scope directories
+     * (~/.wave/skills + ~/.claude/skills + ~/.agents/skills for user skills,
+     * .wave/.claude/.agents/skills under the project for project skills) while
+     * only the highest-priority copy is listed; every copy is removed so one
+     * delete removes the skill completely instead of re-surfacing the next
+     * copy on the next scan. Caches are then re-converged with disk before
+     * returning so the caller's follow-up metadata read reflects the result.
+     * @param name - The skill name as shown in skill metadata
+     * @returns true if the skill was deleted
+     */
+    async deleteSkill(name) {
+        if (!this.initialized) {
+            throw new Error("SkillManager not initialized. Call initialize() first.");
+        }
+        const metadata = this.skillMetadata.get(name);
+        if (!metadata) {
+            return false;
+        }
+        // Builtin and plugin skills are read-only
+        if (metadata.type === "builtin" || metadata.pluginName) {
+            return false;
+        }
+        if (!metadata.skillPath) {
+            return false;
+        }
+        const dirsToRemove = new Set([metadata.skillPath]);
+        for (const root of this.scopeSkillRoots(metadata.type)) {
+            dirsToRemove.add(join(root, name));
+        }
+        for (const dir of dirsToRemove) {
+            await rm(dir, { recursive: true, force: true });
+        }
+        // Converge caches with disk: the serialized full refresh both drops the
+        // deleted entries and reflects any copy that survived deletion. If the
+        // refresh itself fails, fall back to dropping the entry from memory so
+        // the deleted skill does not keep being served.
+        try {
+            await this.refreshSkills();
+        }
+        catch (error) {
+            logger?.warn(`Failed to refresh skills after deleting '${name}': ${error}`);
+            this.skillMetadata.delete(name);
+            this.skillContent.delete(name);
+        }
+        logger?.debug(`Deleted skill '${name}' at ${metadata.skillPath}`);
+        return true;
+    }
 }

package/dist/managers/slashCommandManager.d.ts

@@ -9,6 +9,9 @@ export declare class SlashCommandManager {
     private commands;
     private customCommands;
     private skillCommandIds;
+    /** Ids registered by plugins, so they can be dropped per-plugin and are not
+     * mistaken for disk-sourced custom commands. */
+    private pluginCommandIds;
     private workdir;
     private currentCommandAbortController;
     constructor(container: Container, options: SlashCommandManagerOptions);
@@ -29,6 +32,13 @@ export declare class SlashCommandManager {
      * Register commands from a plugin with namespacing
      */
     registerPluginCommands(pluginName: string, commands: CustomSlashCommand[]): void;
+    /**
+     * Drop every slash command contributed by a plugin, addressed by its plugin
+     * name. Removes the registry entry and the customCommands source entry.
+     * Called by the in-place plugin reload path before re-registering.
+     * @returns the number of commands removed
+     */
+    unregisterPluginCommands(pluginName: string): number;
     /**
      * Reload custom commands (useful for development)
      */