kritya 0.8.10-beta → 0.8.11-beta

package/README.md

@@ -236,6 +236,19 @@ full tool output. `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
   anywhere, including while a permission prompt is on screen. The statusline
   shows `⛔ KILLED`, and both the stop and the release are written to the audit
   log. It's session-only: restarting kritya comes up in the normal state.
+  Some terminals steal `Ctrl+K` for their own shortcuts before kritya ever
+  sees it — VS Code's integrated terminal is the common case, where it's
+  bound as a chord prefix. `/kill [reason]` always works there instead; to
+  get `Ctrl+K` itself working, add a `terminalFocus`-scoped override to VS
+  Code's `keybindings.json`:
+  ```json
+  {
+    "key": "ctrl+k",
+    "command": "workbench.action.terminal.sendSequence",
+    "args": { "text": "\u000b" },
+    "when": "terminalFocus"
+  }
+  ```
 - **Subagents** — the agent can dispatch one or more focused investigations to
   fresh contexts at once (`spawn_agent`), each returning only its findings —
   keeps the main conversation lean on big searches. It can also dispatch

package/dist/headless.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { Agent } from "./agent/loop.js";
+import { KillSwitchError } from "./agent/killSwitch.js";
 import { CONFIG_DIR, legacyGlobalModel, listProviders, loadConfig, loadDotEnv, resolveProvider, } from "./config/config.js";
 import { DEFAULT_MODEL, contextWindowFor } from "./config/models.js";
 import { PermissionManager } from "./permissions/permissions.js";
@@ -184,6 +185,16 @@ export async function runHeadless(args) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.max(1, args.timeoutSeconds) * 1000);
     timer.unref();
+    // Node's default SIGINT/SIGTERM handling kills the process outright —
+    // orphaning background shells/MCP children and leaving no audit trail that
+    // this was a deliberate stop rather than a crash. Route both through the
+    // same kill switch Ctrl+K uses interactively instead, so the turn tears
+    // down cleanly and the stop is logged.
+    const stopForSignal = (sig) => {
+        agent.kill.engage(`stopped by ${sig}`);
+    };
+    process.on("SIGINT", stopForSignal);
+    process.on("SIGTERM", stopForSignal);
     const handlers = {
         onTextDelta: () => { },
         onReasoningDelta: () => { },
@@ -237,12 +248,17 @@ export async function runHeadless(args) {
                 : " No other provider has an API key configured to fall back to.";
             errorMessage = `${err.message}.${hint}`;
         }
+        else if (err instanceof KillSwitchError) {
+            errorMessage = `Stopped (${err.killReason ?? "kill switch engaged"})`;
+        }
         else {
             errorMessage = err instanceof Error ? err.message : String(err);
         }
     }
     finally {
         clearTimeout(timer);
+        process.off("SIGINT", stopForSignal);
+        process.off("SIGTERM", stopForSignal);
         backgroundManager.killAll();
         lspManager.disposeAll();
         shutdownMcp();

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "kritya",
-  "version": "0.8.10-beta",
+  "version": "0.8.11-beta",
   "description": "Kritya — a lean, provider-agnostic terminal coding agent (NVIDIA, OpenAI, OpenRouter, Groq, Ollama, and more)",
   "type": "module",
+  "publishConfig": {
+    "provenance": true
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/GenAICloudDevOps/Kritya.git"

package/dist/agent/plugins.js

@@ -1,408 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-/**
- * Agent Plugins specification: a portable package format for reusable components
- * that extend AI agents. Version 1.0.0 defines a shared format for Agent Skills
- * and MCP servers that compatible clients can discover and load consistently.
- *
- * Plugin structure:
- * my-plugin/
- * ├── plugin.json           # Required manifest
- * ├── skills/               # Agent Skills (in Agent Skills format)
- * ├── mcp.json              # MCP server configuration
- * └── com.example.client/   # Optional client-specific extensions
- *
- * @see https://agent-plugins.org/
- * @see https://developers.googleblog.com/agent-plugins-package-your-skills-tools-and-more/
- */
-/** The agent-plugins manifest file name. */
-export const PLUGIN_MANIFEST_FILE = "plugin.json";
-/** The skills directory name within a plugin. */
-export const SKILLS_DIR_NAME = "skills";
-/** The MCP config file name within a plugin. */
-export const MCP_CONFIG_FILE = "mcp.json";
-/** User-global plugins root, available across all workspaces. */
-export function userPluginsDir() {
-    return path.join(os.homedir(), ".kritya", "plugins");
-}
-/**
- * Get the workspace plugins directory.
- */
-export function pluginsDir(workspace) {
-    return path.join(workspace, ".kritya", "plugins");
-}
-/**
- * Extract plugin ID from manifest.
- * Per spec, id should go in extensions under reverse-domain namespace.
- * For simplicity, we use the plugin directory basename if not in extensions.
- */
-export function getPluginId(manifest, dir) {
-    const extensions = manifest.extensions;
-    if (extensions?.["kritya.id"]) {
-        return extensions["kritya.id"];
-    }
-    // Fallback to basename of plugin directory
-    return path.basename(dir);
-}
-/**
- * Resolve a path relative to the plugin root.
- * Ensures the result stays within the plugin directory.
- * Throws if path escape is detected.
- */
-export function resolvePluginPath(pluginDir, relativePath) {
-    const resolved = path.resolve(pluginDir, relativePath);
-    const normalizedResolved = path.normalize(resolved);
-    const normalizedPlugin = path.normalize(pluginDir);
-    // Check that resolved path starts with plugin directory (plus separator or is same)
-    if (normalizedResolved === normalizedPlugin) {
-        return normalizedResolved;
-    }
-    if (!normalizedResolved.startsWith(normalizedPlugin + path.sep)) {
-        throw new Error(`Path escape detected: ${relativePath} is outside plugin root`);
-    }
-    return normalizedResolved;
-}
-/**
- * Check if a path is contained within the plugin root.
- * Resolves symlinks to verify containment.
- */
-export function isPathContained(pluginDir, candidate) {
-    try {
-        const resolvedPlugin = path.resolve(pluginDir);
-        const resolvedCandidate = path.resolve(candidate);
-        // Resolve symlinks
-        const realPlugin = fs.existsSync(resolvedPlugin) ? fs.realpathSync(resolvedPlugin) : resolvedPlugin;
-        const realCandidate = fs.existsSync(resolvedCandidate) ? fs.realpathSync(resolvedCandidate) : resolvedCandidate;
-        if (realCandidate === realPlugin)
-            return true;
-        if (!realCandidate.startsWith(realPlugin + path.sep))
-            return false;
-        return true;
-    }
-    catch {
-        // If resolution fails, fall back to basic check
-        const resolvedPlugin = path.resolve(pluginDir);
-        const resolvedCandidate = path.resolve(candidate);
-        if (resolvedCandidate === resolvedPlugin)
-            return true;
-        return resolvedCandidate.startsWith(resolvedPlugin + path.sep);
-    }
-}
-/**
- * Validate plugin name per spec constraints:
- * - 1-64 characters
- * - lowercase ASCII letters, digits, hyphens, and periods
- * - begins and ends with alphanumeric
- * - cannot contain consecutive ".." or "--"
- * @returns true if name is valid
- */
-export function isValidPluginName(name) {
-    if (name.length < 1 || name.length > 64)
-        return false;
-    if (!/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(name) && name.length > 1) {
-        return false;
-    }
-    // Forbid consecutive ".." or "--"
-    if (name.includes("..") || name.includes("--"))
-        return false;
-    return true;
-}
-/**
- * Parse a plugin.json manifest file.
- * Validates required fields per spec: $schema (required), name (required).
- * Unknown fields are allowed but reported.
- * @returns null if the file doesn't exist, is invalid JSON, or missing required fields.
- */
-export function parsePluginManifest(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== "object") {
-            return null;
-        }
-        // Per spec v1.0.0, $schema and name are REQUIRED
-        if (typeof parsed.$schema !== "string" || !parsed.$schema.trim()) {
-            return null;
-        }
-        if (typeof parsed.name !== "string" || !parsed.name.trim()) {
-            return null;
-        }
-        // Validate name constraints
-        const name = parsed.name;
-        if (!isValidPluginName(name)) {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Load and parse a plugin manifest from a directory.
- * Returns null if no valid manifest exists or if path escape is detected.
- */
-export function loadPluginManifest(dir) {
-    const manifestPath = path.join(dir, PLUGIN_MANIFEST_FILE);
-    // Check path containment before reading
-    if (!isPathContained(dir, manifestPath)) {
-        return null;
-    }
-    try {
-        const raw = fs.readFileSync(manifestPath, "utf8");
-        return parsePluginManifest(raw);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Discover plugins in a directory tree.
- * Scans immediate subdirectories for plugin.json files.
- * Validates path containment for each discovered plugin.
- */
-export function scanPlugins(root) {
-    const loaded = [];
-    const skipped = [];
-    // Check if root exists and is contained
-    if (!isPathContained(path.dirname(root) || "/", root)) {
-        return { loaded, skipped };
-    }
-    let entries;
-    try {
-        entries = fs.readdirSync(root, { withFileTypes: true });
-    }
-    catch {
-        return { loaded, skipped };
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const dir = path.join(root, entry.name);
-        // Check path containment
-        if (!isPathContained(root, dir)) {
-            skipped.push({
-                dir,
-                reason: "path escape detected - directory outside plugin root",
-            });
-            continue;
-        }
-        const manifest = loadPluginManifest(dir);
-        if (!manifest) {
-            skipped.push({
-                dir,
-                reason: `missing or invalid ${PLUGIN_MANIFEST_FILE}`,
-            });
-            continue;
-        }
-        const skillsDirPath = path.join(dir, SKILLS_DIR_NAME);
-        const mcpConfigPath = path.join(dir, MCP_CONFIG_FILE);
-        // Verify skills directory is contained
-        if (fs.existsSync(skillsDirPath) && !isPathContained(dir, skillsDirPath)) {
-            skipped.push({
-                dir,
-                reason: "skills directory outside plugin root",
-            });
-            continue;
-        }
-        // Verify mcp.json is contained
-        if (fs.existsSync(mcpConfigPath) && !isPathContained(dir, mcpConfigPath)) {
-            skipped.push({
-                dir,
-                reason: "mcp.json outside plugin root",
-            });
-            continue;
-        }
-        const plugin = {
-            id: getPluginId(manifest, dir),
-            name: manifest.name,
-            version: manifest.version,
-            description: manifest.description,
-            dir,
-            manifest,
-            skillsDir: fs.existsSync(skillsDirPath) ? skillsDirPath : undefined,
-            mcpConfigFile: fs.existsSync(mcpConfigPath) ? mcpConfigPath : undefined,
-        };
-        loaded.push(plugin);
-    }
-    return { loaded, skipped };
-}
-/**
- * Scan multiple roots for plugins, merging results.
- * On ID collision, the first plugin found wins.
- * The roots are scanned in order, so earlier roots take precedence.
- */
-export function scanPluginsDetailed(roots) {
-    const seen = new Map();
-    const skipped = [];
-    for (const root of roots) {
-        const { loaded, skipped: rootSkipped } = scanPlugins(root);
-        skipped.push(...rootSkipped);
-        for (const plugin of loaded) {
-            const existing = seen.get(plugin.id);
-            if (existing) {
-                skipped.push({
-                    dir: plugin.dir,
-                    reason: `duplicate plugin ID "${plugin.id}" (already loaded from ${existing.dir})`,
-                });
-                continue;
-            }
-            seen.set(plugin.id, plugin);
-        }
-    }
-    return { loaded: [...seen.values()], skipped };
-}
-/**
- * Scan for plugins across user-global and workspace plugin directories.
- * Project plugins are checked first, then user plugins, so project plugins win on collision.
- */
-export function scanAllPlugins(workspace, userRoot) {
-    const projectRoot = pluginsDir(workspace);
-    const userPluginsRoot = userRoot ?? userPluginsDir();
-    // Project plugins take precedence over user plugins
-    const roots = [projectRoot, userPluginsRoot];
-    return scanPluginsDetailed(roots);
-}
-/**
- * Type guard for MCP server config.
- */
-function isMcpServerConfig(v) {
-    if (!v || typeof v !== "object")
-        return false;
-    const cfg = v;
-    if (!cfg.type)
-        return false;
-    if (cfg.type === "stdio") {
-        return typeof cfg.command === "string";
-    }
-    if (cfg.type === "streamable-http" || cfg.type === "legacy-http-sse") {
-        return typeof cfg.url === "string";
-    }
-    return false;
-}
-/**
- * Expand ${VAR} from process.env; unknown variables are left as-is.
- * Per spec, only command args and env support expansion, not url.
- */
-function expandVars(value) {
-    const VAR_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-    return value.replace(VAR_RE, (whole, name) => {
-        const v = process.env[name];
-        return v !== undefined ? v : whole;
-    });
-}
-/**
- * Expand server config with environment variables and resolve relative paths.
- * Per spec:
- * - command, args, env: expand ${VAR} and resolve relative paths against plugin root
- * - url: expand ${VAR} is NOT allowed per spec
- * - headers: expand ${VAR}
- * - cwd: defaults to plugin root if not specified
- * - PLUGIN_ROOT and PLUGIN_DATA are injected for stdio plugins
- */
-export function expandServerConfig(cfg, pluginDir) {
-    function expandRecord(rec) {
-        if (!rec)
-            return undefined;
-        const out = {};
-        for (const [k, v] of Object.entries(rec))
-            out[k] = expandVars(v);
-        return out;
-    }
-    // Resolve cwd relative to plugin root, defaulting to plugin root if not specified
-    // If path escape is detected, REJECT this entry (throw) - do not fallback
-    let resolvedCwd = pluginDir;
-    if (cfg.cwd) {
-        try {
-            resolvedCwd = resolvePluginPath(pluginDir, cfg.cwd);
-        }
-        catch (err) {
-            // Re-throw to reject this MCP entry
-            throw new Error(`Invalid cwd "${cfg.cwd}": ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // Resolve command relative to plugin root for stdio
-    // If path escape is detected, REJECT this entry (throw) - do not fallback
-    let resolvedCommand;
-    if (cfg.type === "stdio" && cfg.command) {
-        try {
-            resolvedCommand = resolvePluginPath(pluginDir, cfg.command);
-        }
-        catch (err) {
-            // Re-throw to reject this MCP entry
-            throw new Error(`Invalid command "${cfg.command}": ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // Inject PLUGIN_ROOT and PLUGIN_DATA for stdio plugins
-    const env = expandRecord(cfg.env) ?? {};
-    env.PLUGIN_ROOT = pluginDir;
-    env.PLUGIN_DATA = path.join(pluginDir, ".kritya", "plugin-data");
-    return {
-        type: cfg.type,
-        command: resolvedCommand ?? cfg.command,
-        args: cfg.args?.map(expandVars),
-        env,
-        cwd: resolvedCwd,
-        url: cfg.url, // Per spec, ${VAR} expansion is NOT allowed for url
-        headers: expandRecord(cfg.headers),
-        tools: cfg.tools,
-    };
-}
-/**
- * Load MCP servers from an Agent Plugins structure.
- * Reads from plugin/mcp.json if it exists.
- * Validates transport type and path containment.
- * Rejects entries with path escapes instead of falling back.
- */
-export function loadPluginMcpServers(plugin) {
-    if (!plugin.mcpConfigFile)
-        return undefined;
-    // Check path containment
-    if (!isPathContained(plugin.dir, plugin.mcpConfigFile)) {
-        console.warn(`mcp.json is outside plugin root: ${plugin.mcpConfigFile}`);
-        return undefined;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(plugin.mcpConfigFile, "utf8"));
-    }
-    catch (err) {
-        console.warn(`Failed to read MCP config from ${plugin.mcpConfigFile}: ${err}`);
-        return undefined;
-    }
-    // Per spec, mcpServers object is required
-    if (!parsed?.mcpServers || typeof parsed.mcpServers !== "object") {
-        return undefined;
-    }
-    const servers = {};
-    for (const [name, cfg] of Object.entries(parsed.mcpServers)) {
-        if (!isMcpServerConfig(cfg)) {
-            console.warn(`Invalid MCP server config for "${name}": missing required fields`);
-            continue;
-        }
-        // Resolve relative paths and expand env vars
-        // expandServerConfig throws on path escape, which rejects this entry
-        try {
-            const expanded = expandServerConfig(cfg, plugin.dir);
-            servers[name] = expanded;
-        }
-        catch (err) {
-            console.warn(`Rejected MCP server "${name}" in plugin "${plugin.name}": ${err instanceof Error ? err.message : String(err)}`);
-            continue;
-        }
-    }
-    return Object.keys(servers).length ? servers : undefined;
-}
-/**
- * Get plugin directory path for a given plugin ID.
- * This allows looking up where a plugin is installed.
- */
-export function getPluginDirById(workspace, pluginId, userRoot) {
-    const { loaded: plugins } = scanAllPlugins(workspace, userRoot);
-    for (const plugin of plugins) {
-        if (plugin.id === pluginId) {
-            return plugin.dir;
-        }
-    }
-    return undefined;
-}

package/dist/commands/pluginsCommand.js

@@ -1,204 +0,0 @@
-import { scanAllPlugins, loadPluginMcpServers } from "../agent/plugins.js";
-import { connectServer, mcpStatus, replaceStatus, disconnectServer, forgetStatus, isToolOf } from "../mcp/client.js";
-/**
- * The `/plugins` command family: list, show details, and manage plugins.
- *
- * Plugins are Agent Plugins packages that bundle skills and MCP servers
- * into a portable format following the agent-plugins specification.
- *
- * @see https://agent-plugins.org/
- */
-const USAGE = `Usage:
-  /plugins                    list all discovered plugins
-  /plugins <name>             show details for a specific plugin
-  /plugins <name> connect     connect plugins MCP servers to kritya
-  /plugins <name> disconnect  disconnect plugins MCP servers from kritya`;
-export async function runPluginsCommand(ctx) {
-    const parts = ctx.arg.trim().split(/\s+/).filter(Boolean);
-    const sub = parts[0]?.toLowerCase();
-    switch (sub) {
-        case undefined:
-            return listPlugins(ctx);
-        case "connect":
-            return connectPlugin(ctx, parts[1]);
-        case "disconnect":
-            return disconnectPlugin(ctx, parts[1]);
-        default:
-            // If it's not a subcommand, treat it as a plugin name to show details
-            return showPlugin(ctx, sub);
-    }
-}
-function listPlugins(ctx) {
-    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
-    if (!plugins.length) {
-        ctx.addItem({
-            kind: "info",
-            text: "No plugins found.\n\n" +
-                "Plugins are loaded from ~/.kritya/plugins (user-global) and .kritya/plugins (project).\n" +
-                "Create a plugin with a plugin.json manifest, skills/ directory, and optional mcp.json.",
-        });
-        return;
-    }
-    const lines = plugins.map((p) => {
-        const versionInfo = p.version ? ` v${p.version}` : "";
-        const desc = p.description ? ` - ${p.description}` : "";
-        return `  ${p.name}${versionInfo}${desc} (${p.id})`;
-    });
-    ctx.addItem({
-        kind: "info",
-        text: `Plugins:\n${lines.join("\n")}\n\n${USAGE}`,
-    });
-}
-async function showPlugin(ctx, pluginName) {
-    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
-    const plugin = plugins.find((p) => p.name === pluginName || p.id === pluginName);
-    if (!plugin) {
-        ctx.addItem({
-            kind: "info",
-            text: `No plugin named "${pluginName}". Run /plugins to see available plugins.`,
-        });
-        return;
-    }
-    // Report skills - note that they are loaded from plugin.skillsDir
-    const skillsText = plugin.skillsDir
-        ? `Skills: Available from ${plugin.skillsDir}\n(Use /skills to list discovered skills including plugin skills)`
-        : "No skills directory";
-    // Load MCP servers from this plugin
-    const mcpServers = loadPluginMcpServers(plugin);
-    const mcpText = mcpServers
-        ? `MCP Servers (${Object.keys(mcpServers).length}):\n${Object.entries(mcpServers).map(([name, cfg]) => {
-            const target = typeof cfg.command === "string" ? `command: ${cfg.command}` : `url: ${cfg.url}`;
-            return `  - ${name}: ${target}`;
-        }).join("\n")}`
-        : "No MCP servers";
-    // Check if MCP servers are currently connected
-    const status = mcpStatus();
-    const connectedServers = status
-        .filter((s) => s.ok && Object.keys(mcpServers || {}).includes(s.name))
-        .map((s) => s.name);
-    const connectionState = connectedServers.length
-        ? `Connected servers: ${connectedServers.join(", ")}`
-        : "MCP servers not connected";
-    ctx.addItem({
-        kind: "info",
-        text: `Plugin: ${plugin.name} ${plugin.version ? `v${plugin.version}` : ""} (${plugin.id})
-${plugin.description ? `Description: ${plugin.description}` : ""}
-
-${skillsText}
-
-${mcpText}
-
-${connectionState}
-
-${USAGE}`,
-    });
-}
-async function connectPlugin(ctx, pluginName) {
-    if (!pluginName) {
-        ctx.addItem({ kind: "info", text: `Usage: /plugins <name> connect` });
-        return;
-    }
-    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
-    const plugin = plugins.find((p) => p.name === pluginName || p.id === pluginName);
-    if (!plugin) {
-        ctx.addItem({
-            kind: "info",
-            text: `No plugin named "${pluginName}". Run /plugins to see available plugins.`,
-        });
-        return;
-    }
-    // Load MCP servers from this plugin
-    const mcpServers = loadPluginMcpServers(plugin);
-    if (!mcpServers || !Object.keys(mcpServers).length) {
-        ctx.addItem({
-            kind: "info",
-            text: `Plugin "${pluginName}" has no MCP servers to connect.`,
-        });
-        return;
-    }
-    // Connect each server with plugin-specific naming
-    const connected = [];
-    const failed = [];
-    for (const [name, cfg] of Object.entries(mcpServers)) {
-        // Namespace server name with plugin ID to avoid conflicts
-        const pluginNamespace = plugin.id.replace(/[^a-z0-9_-]/g, "_");
-        const serverName = `${pluginNamespace}:${name}`;
-        try {
-            const { tools, status } = await connectServer(serverName, cfg, {
-                tracer: ctx.agent.tracer,
-                audit: ctx.agent.audit,
-                workspace: ctx.workspace,
-            });
-            replaceStatus(status);
-            if (status.ok) {
-                ctx.agent.addTools(tools);
-                connected.push(serverName);
-            }
-            else {
-                failed.push({ name: serverName, error: status.error || "unknown error" });
-            }
-        }
-        catch (err) {
-            failed.push({ name: serverName, error: err instanceof Error ? err.message : String(err) });
-        }
-    }
-    let response = `Plugin "${pluginName}":\n`;
-    if (connected.length) {
-        response += `Connected ${connected.length} server(s): ${connected.join(", ")}\n`;
-    }
-    if (failed.length) {
-        response += `Failed to connect ${failed.length} server(s):\n`;
-        response += failed.map((f) => `  - ${f.name}: ${f.error}`).join("\n");
-    }
-    ctx.addItem({ kind: "info", text: response });
-}
-async function disconnectPlugin(ctx, pluginName) {
-    if (!pluginName) {
-        ctx.addItem({ kind: "info", text: `Usage: /plugins <name> disconnect` });
-        return;
-    }
-    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
-    const plugin = plugins.find((p) => p.name === pluginName || p.id === pluginName);
-    if (!plugin) {
-        ctx.addItem({
-            kind: "info",
-            text: `No plugin named "${pluginName}". Run /plugins to see available plugins.`,
-        });
-        return;
-    }
-    // Load MCP servers from this plugin
-    const mcpServers = loadPluginMcpServers(plugin);
-    if (!mcpServers || !Object.keys(mcpServers).length) {
-        ctx.addItem({
-            kind: "info",
-            text: `Plugin "${pluginName}" has no MCP servers to disconnect.`,
-        });
-        return;
-    }
-    // Disconnect each server
-    const disconnected = [];
-    let removedTools = 0;
-    for (const [name] of Object.entries(mcpServers)) {
-        // Use the same namespace as connect
-        const pluginNamespace = plugin.id.replace(/[^a-z0-9_-]/g, "_");
-        const serverName = `${pluginNamespace}:${name}`;
-        disconnected.push(serverName);
-        // Get tools to remove
-        const status = mcpStatus().find((s) => s.name === serverName && s.ok);
-        if (status) {
-            removedTools += status.tools.length;
-        }
-        // Actually disconnect the server
-        disconnectServer(serverName);
-        // Remove tools from agent
-        ctx.agent.removeTools(isToolOf(serverName));
-        // Forget status so it doesn't remain visible
-        forgetStatus(serverName);
-    }
-    ctx.addItem({
-        kind: "info",
-        text: `Plugin "${pluginName}":\n` +
-            `Disconnected ${disconnected.length} server(s): ${disconnected.join(", ")}\n` +
-            `Removed ${removedTools} tool(s).`,
-    });
-}