wave-agent-sdk 1.1.5 → 1.3.0

package/dist/managers/bashModeManager.js

@@ -0,0 +1,110 @@
+import { bashTool } from "../tools/bashTool.js";
+import { BASH_TOOL_NAME } from "../constants/tools.js";
+/**
+ * Bash mode (`!command`) execution. The command is surfaced as a user-message
+ * tool block (name: BASH_TOOL_NAME) — the same rendering as fork-skill / `/plan`
+ * outputs (⎿ prefix + markdown, result enters the model context via the
+ * generic `<local-command-stdout>` rule) — and executed through the shared
+ * bash tool engine (shell resolution, CWD tracking, timeout, output handling).
+ */
+export class BashModeManager {
+    constructor(container, options) {
+        this.container = container;
+        this.isCommandRunning = false;
+        this.abortController = null;
+        this.workdir = options.workdir;
+    }
+    get messageManager() {
+        return this.container.get("MessageManager");
+    }
+    /**
+     * Merged env (OS env overlaid with this session's settings snapshot) for
+     * bash-mode subprocesses, so settings `env` vars reach them without
+     * polluting other sessions in one `wave --stdio` process.
+     */
+    get sessionEnv() {
+        return (this.container
+            .get("ConfigurationService")
+            ?.getMergedEnv?.() ?? process.env);
+    }
+    setCommandRunning(isRunning) {
+        this.isCommandRunning = isRunning;
+        this.onCommandRunningChange?.(isRunning);
+    }
+    async executeCommand(command) {
+        if (this.isCommandRunning) {
+            throw new Error("Command already running");
+        }
+        this.setCommandRunning(true);
+        try {
+            // User message + running tool block. The user text mirrors the command
+            // itself (`!ls` renders as `!ls`), and incremental toolBlockUpdated
+            // notifications drive the live output on all three hosts.
+            const messageId = this.messageManager.addUserMessage({
+                content: command,
+            });
+            const blockId = this.messageManager.addToolBlockToMessage(messageId, {
+                name: BASH_TOOL_NAME,
+                parameters: command,
+                stage: "running",
+            });
+            this.abortController = new AbortController();
+            const taskManager = this.container.get("TaskManager");
+            // No permissionManager in the context: bash mode is an explicit user
+            // command, it must not be blocked by the permission gate.
+            const result = await bashTool.execute({ command }, {
+                workdir: this.workdir,
+                taskManager,
+                sessionEnv: this.sessionEnv,
+                abortSignal: this.abortController.signal,
+                // Stream realtime output into the running tool block — wired like
+                // aiManager tool execution (aiManager.ts updateToolBlock callbacks).
+                onShortResultUpdate: (shortResult) => {
+                    this.messageManager.updateToolBlock({
+                        id: blockId,
+                        messageId,
+                        shortResult,
+                        stage: "running",
+                        name: BASH_TOOL_NAME,
+                    });
+                },
+                onResultUpdate: (resultText) => {
+                    this.messageManager.updateToolBlock({
+                        id: blockId,
+                        messageId,
+                        result: resultText,
+                        stage: "running",
+                        name: BASH_TOOL_NAME,
+                    });
+                },
+            });
+            const exitCode = typeof result.metadata?.exitCode === "number"
+                ? result.metadata.exitCode
+                : result.success
+                    ? 0
+                    : 1;
+            const resultText = result.success
+                ? result.content
+                : `[exit code: ${exitCode}]` +
+                    (result.content ? `\n\n${result.content}` : "");
+            this.messageManager.updateToolBlock({
+                id: blockId,
+                messageId,
+                result: resultText,
+                shortResult: result.shortResult,
+                stage: "end",
+                success: result.success,
+            });
+            return exitCode;
+        }
+        finally {
+            this.abortController = null;
+            this.setCommandRunning(false);
+        }
+    }
+    abortCommand() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this.isCommandRunning = false;
+    }
+}

package/dist/managers/hookManager.d.ts

@@ -13,6 +13,12 @@ export declare class HookManager {
     private container;
     private configuration;
     private programmaticHooks;
+    /**
+     * Plugin hooks grouped by plugin root path. A map rather than one merged
+     * object because mergeHooksConfiguration only appends — a flat object can
+     * never be reversed, so the in-place plugin reload path could not drop
+     * exactly one plugin's hooks (and re-registering would double them).
+     */
     private pluginHooks;
     private waveConfigHooks;
     private readonly matcher;
@@ -120,6 +126,18 @@ export declare class HookManager {
      * Register hooks provided by a plugin
      */
     registerPluginHooks(pluginRoot: string, hooks: PartialHookConfiguration): void;
+    /**
+     * Drop every hook contributed by a plugin, addressed by its root path.
+     * Used by the in-place plugin reload path (before re-registering) and when a
+     * plugin is disabled or uninstalled.
+     * @returns true if this root had hooks registered
+     */
+    unregisterPluginHooks(pluginRoot: string): boolean;
+    /**
+     * Get hooks registered by plugins (read-only view for the settings UI).
+     * Plugin hooks carry pluginRoot on each command and are read-only in the UI.
+     */
+    getPluginHooks(): PartialHookConfiguration;
     /**
      * Execute SessionStart hooks during initialization.
      * Collects additionalContext and initialUserMessage from hook stdout.

package/dist/managers/hookManager.js

@@ -13,7 +13,13 @@ export class HookManager {
     constructor(container, workdir, matcher = new HookMatcher()) {
         this.container = container;
         this.programmaticHooks = {};
-        this.pluginHooks = {};
+        /**
+         * Plugin hooks grouped by plugin root path. A map rather than one merged
+         * object because mergeHooksConfiguration only appends — a flat object can
+         * never be reversed, so the in-place plugin reload path could not drop
+         * exactly one plugin's hooks (and re-registering would double them).
+         */
+        this.pluginHooks = new Map();
         this.waveConfigHooks = {};
         this.workdir = workdir;
         this.matcher = matcher;
@@ -78,7 +84,9 @@ export class HookManager {
     rebuildConfiguration() {
         const rebuilt = {};
         this.mergeHooksConfiguration(rebuilt, this.programmaticHooks);
-        this.mergeHooksConfiguration(rebuilt, this.pluginHooks);
+        for (const hooks of this.pluginHooks.values()) {
+            this.mergeHooksConfiguration(rebuilt, hooks);
+        }
         this.mergeHooksConfiguration(rebuilt, this.waveConfigHooks);
         this.configuration = Object.keys(rebuilt).length > 0 ? rebuilt : undefined;
     }
@@ -667,9 +675,35 @@ export class HookManager {
                 hooks: config.hooks.map((cmd) => ({ ...cmd, pluginRoot })),
             }));
         }
-        this.mergeHooksConfiguration(this.pluginHooks, stampedHooks);
+        // Replace (not append) the previous registration for this root, so
+        // re-registering the same plugin never doubles its hooks.
+        this.pluginHooks.set(pluginRoot, stampedHooks);
         this.rebuildConfiguration();
     }
+    /**
+     * Drop every hook contributed by a plugin, addressed by its root path.
+     * Used by the in-place plugin reload path (before re-registering) and when a
+     * plugin is disabled or uninstalled.
+     * @returns true if this root had hooks registered
+     */
+    unregisterPluginHooks(pluginRoot) {
+        const removed = this.pluginHooks.delete(pluginRoot);
+        if (removed) {
+            this.rebuildConfiguration();
+        }
+        return removed;
+    }
+    /**
+     * Get hooks registered by plugins (read-only view for the settings UI).
+     * Plugin hooks carry pluginRoot on each command and are read-only in the UI.
+     */
+    getPluginHooks() {
+        const merged = {};
+        for (const hooks of this.pluginHooks.values()) {
+            this.mergeHooksConfiguration(merged, hooks);
+        }
+        return merged;
+    }
     /**
      * Execute SessionStart hooks during initialization.
      * Collects additionalContext and initialUserMessage from hook stdout.

package/dist/managers/liveConfigManager.d.ts

@@ -6,6 +6,7 @@
  * - Configuration file watching for settings.json files
  * - Coordination between file watchers and configuration updates
  */
+import type { TurnConfigurationSnapshot } from "../services/configurationService.js";
 import { Container } from "../utils/container.js";
 import type { WaveConfiguration } from "../types/configuration.js";
 export interface LiveConfigManagerOptions {
@@ -19,6 +20,8 @@ export declare class LiveConfigManager {
     private isInitialized;
     private currentConfiguration;
     private lastValidConfiguration;
+    private turnSnapshot;
+    private turnDepth;
     private fileWatcher;
     private userConfigPaths?;
     private projectConfigPaths?;
@@ -28,6 +31,15 @@ export declare class LiveConfigManager {
     private get hookManager();
     private get permissionManager();
     private get configurationService();
+    private get memoryService();
+    /**
+     * Keep the auto-memory system safe zone in sync with the live auto-memory
+     * toggle (core/agent-config.md scenario 6). Turning auto-memory off must
+     * revoke the privilege its directory got at construction time, and turning it
+     * back on must restore it — both without rebuilding the session. Idempotent:
+     * the underlying add/remove are dedup'ed by path.
+     */
+    private syncAutoMemorySafeZone;
     /**
      * Initialize configuration watching
      * Maps to FR-004: System MUST watch settings.json files
@@ -46,6 +58,19 @@ export declare class LiveConfigManager {
      * Shutdown configuration management and cleanup resources
      */
     shutdown(): Promise<void>;
+    /**
+     * Turn boundary: pin the settings.json-derived configuration for the duration
+     * of a turn (called by AIManager). A live reload may land mid-turn and the
+     * turn must not see it (core/agent-config.md scenario 5) — the change is
+     * picked up by the snapshot taken when the next turn starts. Permission rules,
+     * hooks and env stay live: those are enforcement state and follow the file
+     * immediately.
+     */
+    onTurnStart(): void;
+    /** Turn boundary: drop the snapshot so the next turn reads live values. */
+    onTurnEnd(): void;
+    /** Configuration snapshot of the running turn, or null outside a turn. */
+    getTurnSnapshot(): TurnConfigurationSnapshot | null;
     /**
      * Reload configuration from files
      * Maps to FR-008: Continue with previous valid configuration on errors
@@ -77,6 +102,14 @@ export declare class LiveConfigManager {
     private setupFileWatcherEvents;
     private handleFileChange;
     private detectChanges;
+    /**
+     * Chokidar only starts watching a non-existent path when its parent directory
+     * exists at watch time (a path whose parents are all missing is never
+     * picked up, not even after they appear). Walk up to the deepest node whose
+     * parent exists and watch that instead — events for its descendants still
+     * reach this path's callback (FileWatcherService matches by path prefix).
+     */
+    private resolveWatchTarget;
     /**
      * Get configuration file paths for user and project settings
      * Returns paths in priority order (local.json first, then .json)

package/dist/managers/liveConfigManager.js

@@ -7,7 +7,9 @@
  * - Coordination between file watchers and configuration updates
  */
 import { existsSync } from "fs";
+import { dirname } from "path";
 import { FileWatcherService, } from "../services/fileWatcher.js";
+import { USER_MEMORY_FILE } from "../utils/constants.js";
 import { isValidHookEvent } from "../types/hooks.js";
 import { logger } from "../utils/globalLogger.js";
 export class LiveConfigManager {
@@ -18,6 +20,13 @@ export class LiveConfigManager {
         // Configuration state
         this.currentConfiguration = null;
         this.lastValidConfiguration = null;
+        // Turn-scoped snapshot of the settings.json-derived configuration the running
+        // turn reads from. Captured at turn start, dropped at turn end, so a live
+        // reload landing mid-turn takes effect at the next turn instead of shifting
+        // values under the running one (core/agent-config.md scenario 5). Nested turns
+        // (a subagent turn inside its parent's) share the outer snapshot.
+        this.turnSnapshot = null;
+        this.turnDepth = 0;
         this.isWatching = false;
         this.reloadInProgress = false;
         this.workdir = options.workdir;
@@ -33,6 +42,36 @@ export class LiveConfigManager {
     get configurationService() {
         return this.container.get("ConfigurationService");
     }
+    get memoryService() {
+        return this.container.get("MemoryService");
+    }
+    /**
+     * Keep the auto-memory system safe zone in sync with the live auto-memory
+     * toggle (core/agent-config.md scenario 6). Turning auto-memory off must
+     * revoke the privilege its directory got at construction time, and turning it
+     * back on must restore it — both without rebuilding the session. Idempotent:
+     * the underlying add/remove are dedup'ed by path.
+     */
+    syncAutoMemorySafeZone() {
+        const permissionManager = this.permissionManager;
+        const memoryService = this.memoryService;
+        if (!permissionManager || !memoryService) {
+            return;
+        }
+        const directories = [
+            memoryService.getAutoMemoryDirectory(this.workdir),
+            USER_MEMORY_FILE,
+        ];
+        const enabled = this.configurationService.resolveAutoMemoryEnabledNow();
+        for (const directory of directories) {
+            if (enabled) {
+                permissionManager.addSystemAdditionalDirectory(directory);
+            }
+            else {
+                permissionManager.removeSystemAdditionalDirectory(directory);
+            }
+        }
+    }
     /**
      * Initialize configuration watching
      * Maps to FR-004: System MUST watch settings.json files
@@ -44,18 +83,18 @@ export class LiveConfigManager {
             this.projectConfigPaths = projectPaths;
             // Load initial configuration
             await this.reloadConfiguration();
-            // Start watching user configs that exist
+            // Watch every configuration path, including ones that don't exist yet:
+            // chokidar delivers `add` once a missing path appears, but only if its
+            // parent chain exists when watching starts. Skipping absent paths (the
+            // pre-2026-09-10 behavior) silently dropped the very first save of a
+            // user-level settings.json created after session start
+            // (core/agent-config.md scenario 7).
             for (const userPath of userPaths) {
-                if (existsSync(userPath)) {
-                    await this.fileWatcher.watchFile(userPath, (event) => this.handleFileChange(event, "user"));
-                }
+                await this.fileWatcher.watchFile(this.resolveWatchTarget(userPath), (event) => this.handleFileChange(event, "user"));
             }
-            // Start watching local configs that exist
             if (projectPaths) {
                 for (const projectPath of projectPaths) {
-                    if (existsSync(projectPath)) {
-                        await this.fileWatcher.watchFile(projectPath, (event) => this.handleFileChange(event, "project"));
-                    }
+                    await this.fileWatcher.watchFile(this.resolveWatchTarget(projectPath), (event) => this.handleFileChange(event, "project"));
                 }
             }
             this.isWatching = true;
@@ -112,6 +151,41 @@ export class LiveConfigManager {
             throw error;
         }
     }
+    /**
+     * Turn boundary: pin the settings.json-derived configuration for the duration
+     * of a turn (called by AIManager). A live reload may land mid-turn and the
+     * turn must not see it (core/agent-config.md scenario 5) — the change is
+     * picked up by the snapshot taken when the next turn starts. Permission rules,
+     * hooks and env stay live: those are enforcement state and follow the file
+     * immediately.
+     */
+    onTurnStart() {
+        if (this.turnDepth === 0) {
+            const configuration = this.getCurrentConfiguration();
+            this.turnSnapshot = {
+                configuration: configuration ? structuredClone(configuration) : null,
+                // `env` on the merged configuration is exactly what was published as the
+                // session env snapshot when it was loaded (both come from the same
+                // merge), so the snapshot carries both without querying the service.
+                env: { ...(configuration?.env ?? {}) },
+            };
+        }
+        this.turnDepth++;
+    }
+    /** Turn boundary: drop the snapshot so the next turn reads live values. */
+    onTurnEnd() {
+        if (this.turnDepth === 0) {
+            return;
+        }
+        this.turnDepth--;
+        if (this.turnDepth === 0) {
+            this.turnSnapshot = null;
+        }
+    }
+    /** Configuration snapshot of the running turn, or null outside a turn. */
+    getTurnSnapshot() {
+        return this.turnDepth > 0 ? this.turnSnapshot : null;
+    }
     /**
      * Reload configuration from files
      * Maps to FR-008: Continue with previous valid configuration on errors
@@ -172,15 +246,16 @@ export class LiveConfigManager {
             }
             // Update permission manager if available
             if (this.permissionManager) {
-                this.permissionManager.updateConfiguredPermissionMode(this.currentConfiguration.permissions?.permissionMode);
+                this.permissionManager.updateConfiguredPermissionMode(this.currentConfiguration.permissions?.defaultMode);
                 this.permissionManager.updateAllowedRules(this.currentConfiguration.permissions?.allow || []);
                 this.permissionManager.updateDeniedRules(this.currentConfiguration.permissions?.deny || []);
                 this.permissionManager.updateAdditionalDirectories(this.currentConfiguration.permissions?.additionalDirectories || []);
+                this.syncAutoMemorySafeZone();
             }
             // Trigger reload callback. Awaited so fire-and-forget work spawned by the
             // callback (e.g. skill rediscovery) completes before the reload resolves —
-            // otherwise Agent.create() can return with a cleared skill map (see race
-            // where refreshSkills() clears skillMetadata before async discoverSkills).
+            // otherwise Agent.create() can return while a skill rescan is still
+            // running (refreshSkills swaps caches atomically only after the scan).
             await this.options.onReload?.(this.currentConfiguration);
             return this.currentConfiguration;
         }
@@ -304,6 +379,26 @@ export class LiveConfigManager {
         }
         return { added, modified, removed };
     }
+    /**
+     * Chokidar only starts watching a non-existent path when its parent directory
+     * exists at watch time (a path whose parents are all missing is never
+     * picked up, not even after they appear). Walk up to the deepest node whose
+     * parent exists and watch that instead — events for its descendants still
+     * reach this path's callback (FileWatcherService matches by path prefix).
+     */
+    resolveWatchTarget(configPath) {
+        let candidate = configPath;
+        while (!existsSync(dirname(candidate))) {
+            const parent = dirname(candidate);
+            if (parent === candidate) {
+                // Reached the filesystem root without an existing parent: nothing to
+                // watch (unreachable for absolute paths).
+                return configPath;
+            }
+            candidate = parent;
+        }
+        return candidate;
+    }
     /**
      * Get configuration file paths for user and project settings
      * Returns paths in priority order (local.json first, then .json)

package/dist/managers/lspManager.d.ts

@@ -21,6 +21,14 @@ export declare class LspManager implements ILspManager {
     constructor(container: Container);
     initialize(workdir: string): Promise<void>;
     registerServer(language: string, config: LspServerConfig): void;
+    /**
+     * Drop every LSP server contributed by a plugin (matched on pluginRoot),
+     * stopping any process already started for those languages so the next
+     * request starts the reloaded command instead of reusing the stale one.
+     * Called by the in-place plugin reload path before re-registering.
+     * @returns the number of servers removed
+     */
+    unregisterServersForPlugin(pluginRoot: string): Promise<number>;
     private loadConfig;
     getProcessForFile(filePath: string): Promise<LspProcess | null>;
     private startServer;
@@ -36,6 +44,7 @@ export declare class LspManager implements ILspManager {
         success: boolean;
         content: string;
     }>;
+    private stopProcess;
     cleanup(): Promise<void>;
 }
 export {};

package/dist/managers/lspManager.js

@@ -17,6 +17,32 @@ export class LspManager {
         this.config[language] = config;
         logger?.debug(`Registered LSP server for ${language}`);
     }
+    /**
+     * Drop every LSP server contributed by a plugin (matched on pluginRoot),
+     * stopping any process already started for those languages so the next
+     * request starts the reloaded command instead of reusing the stale one.
+     * Called by the in-place plugin reload path before re-registering.
+     * @returns the number of servers removed
+     */
+    async unregisterServersForPlugin(pluginRoot) {
+        let removed = 0;
+        for (const [language, config] of Object.entries(this.config)) {
+            if (config.pluginRoot !== pluginRoot) {
+                continue;
+            }
+            delete this.config[language];
+            const lspProc = this.processes.get(language);
+            if (lspProc) {
+                this.processes.delete(language);
+                await this.stopProcess(language, lspProc);
+            }
+            removed += 1;
+        }
+        if (removed > 0) {
+            logger?.debug(`Unregistered ${removed} LSP servers for plugin root ${pluginRoot}`);
+        }
+        return removed;
+    }
     async loadConfig() {
         const lspJsonPath = join(this.workdir, ".lsp.json");
         try {
@@ -326,27 +352,30 @@ export class LspManager {
             return { success: false, content: `LSP error: ${JSON.stringify(error)}` };
         }
     }
-    async cleanup() {
-        for (const [language, lspProc] of this.processes.entries()) {
-            try {
-                // Try graceful shutdown
-                const timeout = lspProc.config.shutdownTimeout || 2000;
-                await this.sendRequest(lspProc, "shutdown", {}, timeout);
-                await this.sendNotification(lspProc, "exit", {});
-                // Give it a moment to exit
-                if (timeout > 100) {
-                    await new Promise((resolve) => setTimeout(resolve, 100));
-                }
-            }
-            catch (error) {
-                logger?.debug(`Failed to gracefully shutdown LSP for ${language}: ${error}`);
+    async stopProcess(language, lspProc) {
+        try {
+            // Try graceful shutdown
+            const timeout = lspProc.config.shutdownTimeout || 2000;
+            await this.sendRequest(lspProc, "shutdown", {}, timeout);
+            await this.sendNotification(lspProc, "exit", {});
+            // Give it a moment to exit
+            if (timeout > 100) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
             }
-            finally {
-                if (!lspProc.process.killed) {
-                    lspProc.process.kill();
-                }
+        }
+        catch (error) {
+            logger?.debug(`Failed to gracefully shutdown LSP for ${language}: ${error}`);
+        }
+        finally {
+            if (!lspProc.process.killed) {
+                lspProc.process.kill();
             }
         }
+    }
+    async cleanup() {
+        for (const [language, lspProc] of this.processes.entries()) {
+            await this.stopProcess(language, lspProc);
+        }
         this.processes.clear();
     }
 }

package/dist/managers/mcpManager.d.ts

@@ -1,7 +1,7 @@
 import { ChatCompletionFunctionTool } from "openai/resources.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
 import { Container } from "../utils/container.js";
-import type { Logger, McpServerConfig, McpConfig, McpTool, McpServerStatus } from "../types/index.js";
+import type { Logger, McpServerConfig, McpConfig, McpTool, McpToolCallResult, McpServerStatus } from "../types/index.js";
 export interface McpManagerCallbacks {
     onMcpServersChange?: (servers: McpServerStatus[]) => void;
 }
@@ -32,11 +32,14 @@ export declare class McpManager {
     private servers;
     private connections;
     private configPath;
+    private userConfigPath;
     private workdir;
     private callbacks;
     private mcpServers;
     private reconnectTimers;
     private reconnectAttempts;
+    /** Explicit disconnectServer teardowns currently in flight */
+    private disconnecting;
     constructor(container: Container, options?: McpManagerOptions);
     /**
      * Merged env for this session: OS env overlaid with the per-session settings
@@ -50,13 +53,61 @@ export declare class McpManager {
     initialize(workdir: string, autoConnect?: boolean): Promise<void>;
     ensureConfigLoaded(): Promise<McpConfig | null>;
     loadConfig(): Promise<McpConfig | null>;
+    /**
+     * Read a raw MCP config file, tolerating ENOENT and corrupt JSON.
+     */
+    private readConfigFile;
+    /**
+     * The user-level MCP config path (~/.wave/mcp.json).
+     */
+    getUserConfigPath(): string;
+    /**
+     * The project-level MCP config path (<workdir>/.mcp.json).
+     */
+    getProjectConfigPath(): string;
     saveConfig(config: McpConfig): Promise<boolean>;
     getConfig(): McpConfig | null;
     getAllServers(): McpServerStatus[];
     getServer(name: string): McpServerStatus | undefined;
+    /**
+     * The usage notes each usable server described about itself (`initialize`'s
+     * `instructions`), for the announcement appended to the conversation.
+     *
+     * "Usable" is the same predicate `getAllConnectedTools` uses — connected, or
+     * reconnecting with its last-known snapshot retained — so a server's prose is
+     * visible exactly while its tools are. A server that dropped, failed to connect
+     * or went to `error` keeps its snapshot but stops being reported here, which is
+     * what keeps a dead server from still talking to the model.
+     *
+     * `isDenied` receives flattened tool names (`mcp__server__tool`, the shape
+     * permission rules match on); a server whose tools are *all* excluded by rules is
+     * dropped whole, so prose cannot reach the context after the user ruled the
+     * server out. A server exposing no tools at all is still reported: nothing was
+     * excluded, it is simply a server that brings context rather than tools.
+     */
+    getServerInstructions(isDenied?: (toolName: string) => boolean): Array<{
+        name: string;
+        instructions: string;
+    }>;
     updateServerStatus(name: string, updates: Partial<McpServerStatus>): void;
     addServer(name: string, config: McpServerConfig): boolean;
     removeServer(name: string): boolean;
+    /**
+     * Drop every MCP server contributed by a plugin (matched on pluginRoot),
+     * disconnecting each one. Needed instead of re-adding under the same name
+     * because addServer refuses a name that is already registered.
+     * Called by the in-place plugin reload path before re-registering.
+     * @returns the number of servers removed
+     */
+    removeServersForPlugin(pluginRoot: string): number;
+    /**
+     * Remove a server from a persisted config file (user or project scope),
+     * then disconnect and drop it from the in-memory registry.
+     * @param scope - "user" removes from ~/.wave/mcp.json; "project" removes from <workdir>/.mcp.json
+     * @param name - The server name
+     * @returns true if the server was found and removed
+     */
+    removeServerFromConfig(scope: "user" | "project", name: string): Promise<boolean>;
     connectServer(name: string): Promise<boolean>;
     /**
      * Schedule auto-reconnect with exponential backoff.
@@ -71,15 +122,7 @@ export declare class McpManager {
     private cancelReconnect;
     disconnectServer(name: string): Promise<boolean>;
     getAllConnectedTools(): McpTool[];
-    executeMcpTool(toolName: string, args: Record<string, unknown>, context?: ToolContext): Promise<{
-        success: boolean;
-        content: string;
-        serverName?: string;
-        images?: Array<{
-            data: string;
-            mediaType?: string;
-        }>;
-    }>;
+    executeMcpTool(toolName: string, args: Record<string, unknown>, context?: ToolContext): Promise<McpToolCallResult>;
     private executeToolOnConnection;
     cleanup(): Promise<void>;
     /**
@@ -90,6 +133,21 @@ export declare class McpManager {
      * Get all currently available MCP tools as OpenAI function tools
      */
     getMcpToolsConfig(): ChatCompletionFunctionTool[];
+    /**
+     * Declared output schema per flattened tool name, for the Exec catalog's return
+     * types.
+     *
+     * A separate accessor because `getMcpToolsConfig()` cannot carry it: an OpenAI
+     * function declaration has room for `parameters` and nothing else, so the schema
+     * a server declared for its *output* has no field to travel in. Correlated with
+     * the same `findToolServer` lookup `getMcpToolPlugins` uses and keyed with the
+     * same `mcpToolFlatName`, so the two agree on which server owns a tool.
+     *
+     * Servers that declare no output schema are simply absent, which renders as
+     * `Promise<unknown>`: honest about the call returning *something* of unspecified
+     * shape.
+     */
+    getMcpToolOutputSchemas(): Map<string, Record<string, unknown>>;
     /**
      * Execute an MCP tool by name (registry version)
      */