wispy-cli 0.3.2 → 0.4.0

package/bin/wispy-tui.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+/**
+ * wispy-tui — Ink-based TUI entry point
+ * Delegates to lib/wispy-tui.mjs
+ */
+
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const tuiScript = path.join(__dirname, "..", "lib", "wispy-tui.mjs");
+
+await import(tuiScript);

package/bin/wispy.mjs

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
 
-// Wispy CLI entry point — delegates to the main REPL
+/**
+ * Wispy CLI entry point
+ *
+ * Flags:
+ *   --tui    Launch Ink-based TUI mode
+ *   (default) Launch interactive REPL
+ */
+
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const mainScript = path.join(__dirname, "..", "lib", "wispy-repl.mjs");
 
-// Dynamic import of the main module
-await import(mainScript);
+// Check for --tui flag
+const args = process.argv.slice(2);
+const tuiMode = args.includes("--tui");
+
+if (tuiMode) {
+  // Remove --tui from args so wispy-tui doesn't see it
+  const newArgs = args.filter(a => a !== "--tui");
+  process.argv = [process.argv[0], process.argv[1], ...newArgs];
+  const tuiScript = path.join(__dirname, "..", "lib", "wispy-tui.mjs");
+  await import(tuiScript);
+} else {
+  const mainScript = path.join(__dirname, "..", "lib", "wispy-repl.mjs");
+  await import(mainScript);
+}

package/lib/mcp-client.mjs

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+/**
+ * mcp-client.mjs — MCP (Model Context Protocol) client for Wispy
+ *
+ * Implements:
+ *   - stdio transport (spawn server process, communicate over stdin/stdout)
+ *   - JSON-RPC 2.0 framing (newline-delimited)
+ *   - initialize / tools/list / tools/call
+ *   - MCPManager: manages multiple named server connections
+ */
+
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import readline from "node:readline";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// ---------------------------------------------------------------------------
+// MCPClient — single server connection
+// ---------------------------------------------------------------------------
+
+export class MCPClient extends EventEmitter {
+  constructor(name, config) {
+    super();
+    this.name = name;
+    this.config = config; // { command, args?, env?, cwd? }
+    this.process = null;
+    this.rl = null;
+    this._requestId = 0;
+    this._pending = new Map(); // id → { resolve, reject, timer }
+    this.tools = [];
+    this.connected = false;
+    this.initialized = false;
+    this.serverInfo = null;
+  }
+
+  async connect() {
+    const { command, args = [], env = {}, cwd } = this.config;
+
+    this.process = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+      cwd: cwd ?? undefined,
+    });
+
+    this.process.on("error", (err) => {
+      this.connected = false;
+      this.emit("error", err);
+      this._rejectAll(err);
+    });
+
+    this.process.on("exit", (code) => {
+      this.connected = false;
+      this.initialized = false;
+      this.emit("disconnect", code);
+      this._rejectAll(new Error(`MCP server "${this.name}" exited with code ${code}`));
+    });
+
+    // Read JSON-RPC messages from stdout (newline-delimited)
+    this.rl = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity,
+    });
+    this.rl.on("line", (line) => this._handleLine(line.trim()));
+
+    // Collect stderr for debugging
+    this._stderrBuf = "";
+    this.process.stderr.on("data", (data) => {
+      this._stderrBuf += data.toString();
+      this.emit("stderr", data.toString());
+    });
+
+    this.connected = true;
+
+    // Run MCP handshake
+    await this._initialize();
+    return this;
+  }
+
+  async _initialize() {
+    const result = await this._request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        roots: { listChanged: false },
+        sampling: {},
+      },
+      clientInfo: {
+        name: "wispy",
+        version: "0.5.0",
+      },
+    });
+
+    this.serverInfo = result?.serverInfo ?? null;
+
+    // Send initialized notification (required by spec)
+    this._notify("notifications/initialized", {});
+    this.initialized = true;
+    this.emit("ready", result);
+    return result;
+  }
+
+  async listTools() {
+    const result = await this._request("tools/list", {});
+    this.tools = result?.tools ?? [];
+    return this.tools;
+  }
+
+  async callTool(name, args = {}) {
+    const result = await this._request("tools/call", {
+      name,
+      arguments: args,
+    });
+    return result;
+  }
+
+  disconnect() {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    if (this.process) {
+      try { this.process.stdin.end(); } catch {}
+      try { this.process.kill("SIGTERM"); } catch {}
+      this.process = null;
+    }
+    this.connected = false;
+    this.initialized = false;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal JSON-RPC helpers
+  // ---------------------------------------------------------------------------
+
+  _handleLine(line) {
+    if (!line) return;
+    try {
+      const msg = JSON.parse(line);
+      // Response to a pending request
+      if (msg.id !== undefined && this._pending.has(msg.id)) {
+        const { resolve, reject } = this._pending.get(msg.id);
+        this._pending.delete(msg.id);
+        if (msg.error) {
+          reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+        } else {
+          resolve(msg.result);
+        }
+      } else if (msg.method) {
+        // Server-initiated notification or request
+        this.emit("notification", msg);
+      }
+    } catch {
+      // Non-JSON line (server logs etc.) — ignore
+    }
+  }
+
+  _request(method, params, timeoutMs = 30_000) {
+    return new Promise((resolve, reject) => {
+      if (!this.connected || !this.process) {
+        return reject(new Error(`MCP server "${this.name}" is not connected`));
+      }
+
+      const id = ++this._requestId;
+      const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+
+      const timer = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this._pending.set(id, {
+        resolve: (val) => { clearTimeout(timer); resolve(val); },
+        reject: (err) => { clearTimeout(timer); reject(err); },
+      });
+
+      try {
+        this.process.stdin.write(msg + "\n");
+      } catch (err) {
+        this._pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+
+  _notify(method, params) {
+    if (!this.connected || !this.process) return;
+    const msg = JSON.stringify({ jsonrpc: "2.0", method, params });
+    try {
+      this.process.stdin.write(msg + "\n");
+    } catch { /* ignore */ }
+  }
+
+  _rejectAll(err) {
+    for (const { reject } of this._pending.values()) {
+      reject(err);
+    }
+    this._pending.clear();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// MCPManager — manages multiple named server connections
+// ---------------------------------------------------------------------------
+
+export class MCPManager {
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.clients = new Map(); // name → MCPClient
+    this._toolIndex = new Map(); // wispyName → { serverName, mcpName, inputSchema, description }
+  }
+
+  // Load ~/.wispy/mcp.json (creates default if missing)
+  async loadConfig() {
+    try {
+      const raw = await readFile(this.configPath, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return { mcpServers: {} };
+    }
+  }
+
+  // Save updated config
+  async saveConfig(config) {
+    await mkdir(path.dirname(this.configPath), { recursive: true });
+    await writeFile(this.configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+  }
+
+  // Auto-connect all non-disabled servers from config
+  async autoConnect() {
+    const config = await this.loadConfig();
+    const servers = config.mcpServers ?? {};
+    const results = [];
+
+    for (const [name, serverConfig] of Object.entries(servers)) {
+      if (serverConfig.disabled) {
+        results.push({ name, status: "disabled" });
+        continue;
+      }
+      try {
+        const client = await this.connect(name, serverConfig);
+        results.push({ name, status: "connected", tools: client.tools.length });
+      } catch (err) {
+        results.push({ name, status: "failed", error: err.message.slice(0, 200) });
+      }
+    }
+
+    return results;
+  }
+
+  // Connect a single server by name + config
+  async connect(name, serverConfig) {
+    // Disconnect existing connection if any
+    if (this.clients.has(name)) {
+      this.clients.get(name).disconnect();
+      this.clients.delete(name);
+    }
+
+    const client = new MCPClient(name, serverConfig);
+    await client.connect();
+    await client.listTools();
+
+    this.clients.set(name, client);
+    this._rebuildToolIndex();
+
+    return client;
+  }
+
+  // Disconnect a single server by name
+  disconnect(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      client.disconnect();
+      this.clients.delete(name);
+      this._rebuildToolIndex();
+      return true;
+    }
+    return false;
+  }
+
+  // Disconnect all servers
+  disconnectAll() {
+    for (const client of this.clients.values()) {
+      try { client.disconnect(); } catch {}
+    }
+    this.clients.clear();
+    this._toolIndex.clear();
+  }
+
+  // Rebuild the flat tool index after connections change
+  _rebuildToolIndex() {
+    this._toolIndex.clear();
+    for (const [serverName, client] of this.clients.entries()) {
+      for (const tool of client.tools) {
+        // Prefix to avoid name collisions: mcp_<server>_<tool>
+        const wispyName = `mcp_${serverName}_${tool.name}`.replace(/[^a-zA-Z0-9_]/g, "_");
+        this._toolIndex.set(wispyName, {
+          wispyName,
+          serverName,
+          mcpName: tool.name,
+          description: `[MCP:${serverName}] ${tool.description ?? tool.name}`,
+          inputSchema: tool.inputSchema ?? { type: "object", properties: {}, required: [] },
+        });
+      }
+    }
+  }
+
+  // Execute an MCP tool call by its wispy name
+  async callTool(wispyName, args) {
+    const toolInfo = this._toolIndex.get(wispyName);
+    if (!toolInfo) throw new Error(`MCP tool not found: ${wispyName}`);
+
+    const client = this.clients.get(toolInfo.serverName);
+    if (!client?.connected) throw new Error(`MCP server not connected: ${toolInfo.serverName}`);
+
+    return client.callTool(toolInfo.mcpName, args);
+  }
+
+  // Returns tool definitions in Wispy TOOL_DEFINITIONS format
+  getToolDefinitions() {
+    return Array.from(this._toolIndex.values()).map(t => ({
+      name: t.wispyName,
+      description: t.description,
+      parameters: t.inputSchema,
+    }));
+  }
+
+  // Check if a tool name is an MCP tool
+  hasTool(wispyName) {
+    return this._toolIndex.has(wispyName);
+  }
+
+  // Get all tools as a flat array
+  getAllTools() {
+    return Array.from(this._toolIndex.values());
+  }
+
+  // Get connection status for all known servers
+  getStatus() {
+    return Array.from(this.clients.entries()).map(([name, client]) => ({
+      name,
+      connected: client.connected,
+      initialized: client.initialized,
+      toolCount: client.tools.length,
+      tools: client.tools.map(t => t.name),
+      serverInfo: client.serverInfo,
+    }));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Default MCP config writer (call once at first run)
+// ---------------------------------------------------------------------------
+
+export async function ensureDefaultMcpConfig(configPath) {
+  try {
+    await readFile(configPath, "utf8");
+    // Already exists — don't overwrite
+  } catch {
+    const defaultConfig = {
+      mcpServers: {
+        // Example: filesystem server (disabled by default)
+        filesystem: {
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-filesystem", os.homedir()],
+          disabled: true,
+          description: "MCP filesystem server — access files via MCP protocol",
+        },
+        // Example: fetch server (disabled by default)
+        fetch: {
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-fetch"],
+          disabled: true,
+          description: "MCP fetch server — HTTP fetch via MCP protocol",
+        },
+      },
+    };
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf8");
+  }
+}

package/lib/wispy-repl.mjs

@@ -15,6 +15,8 @@ import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath as _fileURLToPath } from "node:url";
+import { MCPManager, ensureDefaultMcpConfig } from "./mcp-client.mjs";
 
 // ---------------------------------------------------------------------------
 // Config
@@ -22,6 +24,10 @@ import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 
 const WISPY_DIR = path.join(os.homedir(), ".wispy");
 const MEMORY_DIR = path.join(WISPY_DIR, "memory");
+const MCP_CONFIG_PATH = path.join(WISPY_DIR, "mcp.json");
+
+// Global MCP manager — initialized at startup
+const mcpManager = new MCPManager(MCP_CONFIG_PATH);
 
 // Workstream-aware conversation storage
 // wispy -w "project-name" → separate conversation per workstream
@@ -619,6 +625,11 @@ function optimizeContext(messages, maxTokens = 30_000) {
 // Tool definitions (Gemini function calling format)
 // ---------------------------------------------------------------------------
 
+// Returns merged static + dynamically registered MCP tool definitions
+function getAllToolDefinitions() {
+  return [...TOOL_DEFINITIONS, ...mcpManager.getToolDefinitions()];
+}
+
 const TOOL_DEFINITIONS = [
   {
     name: "read_file",
@@ -1465,6 +1476,22 @@ Be concise. Your output feeds into the next stage.`;
       }
 
       default: {
+        // Check MCP tools first
+        if (mcpManager.hasTool(name)) {
+          try {
+            const result = await mcpManager.callTool(name, args);
+            // MCP tools/call returns { content: [{type, text}], isError? }
+            if (result?.isError) {
+              const errText = result.content?.map(c => c.text ?? "").join("") ?? "MCP tool error";
+              return { success: false, error: errText };
+            }
+            const output = result?.content?.map(c => c.text ?? c.data ?? JSON.stringify(c)).join("\n") ?? JSON.stringify(result);
+            return { success: true, output };
+          } catch (err) {
+            return { success: false, error: `MCP tool error: ${err.message}` };
+          }
+        }
+
         // Unknown tool — try to execute as a skill via run_command
         // This handles cases where the AI hallucinates tools from skill descriptions
         const skills = await loadSkills();
@@ -1476,7 +1503,7 @@ Be concise. Your output feeds into the next stage.`;
             skill_hint: matchedSkill.body.slice(0, 500),
           };
         }
-        return { success: false, error: `Unknown tool: ${name}. Available: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result` };
+        return { success: false, error: `Unknown tool: ${name}. Available: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result, and MCP tools (see /mcp list)` };
       }
     }
   } catch (err) {
@@ -1599,7 +1626,7 @@ async function buildSystemPrompt(messages = []) {
     "  - NEVER reply in Korean when the user wrote in English.",
     "",
     "## Tools",
-    "You have 18 tools: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result.",
+    `You have ${18 + mcpManager.getAllTools().length} tools: read_file, write_file, file_edit, file_search, run_command, list_directory, git, web_search, web_fetch, keychain, clipboard, spawn_agent, spawn_async_agent, pipeline, ralph_loop, update_plan, list_agents, get_agent_result${mcpManager.getAllTools().length > 0 ? ", and MCP tools: " + mcpManager.getAllTools().map(t => t.wispyName).join(", ") : ""}.`,
     "- file_edit: for targeted text replacement (prefer over write_file for edits)",
     "- file_search: grep across codebase",
     "- git: any git command",
@@ -1711,7 +1738,7 @@ async function chatGeminiWithTools(messages, onChunk) {
   sessionTokens.input += estimateTokens(systemInstruction + inputText);
 
   const geminiTools = [{
-    functionDeclarations: TOOL_DEFINITIONS.map(t => ({
+    functionDeclarations: getAllToolDefinitions().map(t => ({
       name: t.name,
       description: t.description,
       parameters: t.parameters,
@@ -1801,7 +1828,7 @@ async function chatOpenAIWithTools(messages, onChunk) {
     return { role: m.role === "assistant" ? "assistant" : m.role, content: m.content };
   });
 
-  const openaiTools = TOOL_DEFINITIONS.map(t => ({
+  const openaiTools = getAllToolDefinitions().map(t => ({
     type: "function",
     function: { name: t.name, description: t.description, parameters: t.parameters },
   }));
@@ -1879,7 +1906,7 @@ async function chatAnthropicWithTools(messages, onChunk) {
   const inputText = anthropicMessages.map(m => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("");
   sessionTokens.input += estimateTokens(systemPrompt + inputText);
 
-  const anthropicTools = TOOL_DEFINITIONS.map(t => ({
+  const anthropicTools = getAllToolDefinitions().map(t => ({
     name: t.name,
     description: t.description,
     input_schema: t.parameters,
@@ -2321,6 +2348,119 @@ ${bold("Wispy Commands:")}
     process.exit(0);
   }
 
+  // ---------------------------------------------------------------------------
+  // /mcp — MCP server management
+  // ---------------------------------------------------------------------------
+  if (cmd === "/mcp") {
+    const sub = parts[1] ?? "list";
+
+    if (sub === "list") {
+      const status = mcpManager.getStatus();
+      const allTools = mcpManager.getAllTools();
+      if (status.length === 0) {
+        console.log(dim("No MCP servers connected."));
+        console.log(dim(`Config: ${MCP_CONFIG_PATH}`));
+        console.log(dim("Use /mcp connect <name> to connect a server."));
+      } else {
+        console.log(bold(`\n🔌 MCP Servers (${status.length}):\n`));
+        for (const s of status) {
+          const icon = s.connected ? green("●") : red("○");
+          const toolList = s.tools.length > 0
+            ? dim(` [${s.tools.slice(0, 5).join(", ")}${s.tools.length > 5 ? "..." : ""}]`)
+            : "";
+          console.log(`  ${icon} ${bold(s.name.padEnd(18))} ${s.toolCount} tools${toolList}`);
+          if (s.serverInfo?.name) console.log(dim(`      server: ${s.serverInfo.name} v${s.serverInfo.version ?? "?"}`));
+        }
+      }
+      if (allTools.length > 0) {
+        console.log(bold(`\n🧰 MCP Tools (${allTools.length} total):\n`));
+        for (const t of allTools) {
+          console.log(`  ${cyan(t.wispyName.padEnd(30))} ${dim(t.description.slice(0, 60))}`);
+        }
+      }
+      console.log("");
+      return true;
+    }
+
+    if (sub === "connect") {
+      const serverName = parts[2];
+      if (!serverName) {
+        console.log(yellow("Usage: /mcp connect <server-name>"));
+        return true;
+      }
+      const config = await mcpManager.loadConfig();
+      const serverConfig = config.mcpServers?.[serverName];
+      if (!serverConfig) {
+        console.log(red(`Server "${serverName}" not found in ${MCP_CONFIG_PATH}`));
+        console.log(dim(`Available: ${Object.keys(config.mcpServers ?? {}).join(", ") || "none"}`));
+        return true;
+      }
+      process.stdout.write(dim(`  Connecting to "${serverName}"...`));
+      try {
+        const client = await mcpManager.connect(serverName, serverConfig);
+        console.log(green(` ✓ connected (${client.tools.length} tools)`));
+        if (client.tools.length > 0) {
+          console.log(dim(`  Tools: ${client.tools.map(t => t.name).join(", ")}`));
+        }
+      } catch (err) {
+        console.log(red(` ✗ failed: ${err.message.slice(0, 120)}`));
+      }
+      return true;
+    }
+
+    if (sub === "disconnect") {
+      const serverName = parts[2];
+      if (!serverName) {
+        console.log(yellow("Usage: /mcp disconnect <server-name>"));
+        return true;
+      }
+      const ok = mcpManager.disconnect(serverName);
+      console.log(ok ? green(`✓ Disconnected "${serverName}"`) : yellow(`"${serverName}" was not connected`));
+      return true;
+    }
+
+    if (sub === "config") {
+      console.log(dim(`Config file: ${MCP_CONFIG_PATH}`));
+      try {
+        const cfg = await mcpManager.loadConfig();
+        const servers = cfg.mcpServers ?? {};
+        console.log(bold(`\nDefined servers (${Object.keys(servers).length}):\n`));
+        for (const [name, s] of Object.entries(servers)) {
+          const status = s.disabled ? dim("disabled") : green("enabled");
+          console.log(`  ${name.padEnd(20)} ${status}`);
+          console.log(dim(`    cmd: ${s.command} ${(s.args ?? []).join(" ")}`));
+        }
+      } catch {
+        console.log(dim("No config found."));
+      }
+      return true;
+    }
+
+    if (sub === "reload") {
+      console.log(dim("Reloading MCP servers..."));
+      mcpManager.disconnectAll();
+      const results = await mcpManager.autoConnect();
+      for (const r of results) {
+        if (r.status === "connected") console.log(green(`  ✓ ${r.name} (${r.tools} tools)`));
+        else if (r.status === "disabled") console.log(dim(`  ○ ${r.name} (disabled)`));
+        else console.log(red(`  ✗ ${r.name}: ${r.error?.slice(0, 80)}`));
+      }
+      return true;
+    }
+
+    // Unknown subcommand
+    console.log(`
+${bold("/mcp commands:")}
+  ${cyan("/mcp list")}                  List connected servers and tools
+  ${cyan("/mcp connect <name>")}        Connect a server from config
+  ${cyan("/mcp disconnect <name>")}     Disconnect a server
+  ${cyan("/mcp config")}               Show mcp.json config
+  ${cyan("/mcp reload")}               Reconnect all servers
+  ${dim(`Config: ${MCP_CONFIG_PATH}`)}
+`);
+    return true;
+  }
+
   return false;
 }
 
@@ -2618,6 +2758,28 @@ if (!API_KEY && PROVIDER !== "ollama") {
   }
 }
 
+// Auto-connect MCP servers from ~/.wispy/mcp.json
+await ensureDefaultMcpConfig(MCP_CONFIG_PATH);
+{
+  const mcpResults = await mcpManager.autoConnect();
+  const connected = mcpResults.filter(r => r.status === "connected");
+  const failed = mcpResults.filter(r => r.status === "failed");
+  if (connected.length > 0) {
+    // Quiet success — only show if verbose
+    // console.log(dim(`🔌 MCP: ${connected.map(r => `${r.name}(${r.tools})`).join(", ")}`));
+  }
+  if (failed.length > 0 && process.env.WISPY_DEBUG) {
+    for (const r of failed) {
+      console.error(dim(`⚠ MCP "${r.name}" failed: ${r.error?.slice(0, 80)}`));
+    }
+  }
+}
+
+// Graceful MCP cleanup on exit
+process.on("exit", () => { try { mcpManager.disconnectAll(); } catch {} });
+process.on("SIGINT", () => { mcpManager.disconnectAll(); process.exit(0); });
+process.on("SIGTERM", () => { mcpManager.disconnectAll(); process.exit(0); });
+
 // Auto-start server before entering REPL or one-shot
 const serverStatus = await startServerIfNeeded();
 if (serverStatus.started) {