run-mcp 1.5.1 → 1.6.1

package/dist/index.js

@@ -2,12 +2,142 @@
 
 // src/index.ts
 import { program } from "commander";
+import { createConnection, createServer } from "net";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join2, resolve } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { spawn } from "child_process";
 
-// src/repl.ts
+// src/config-scanner.ts
+import { existsSync } from "fs";
 import { readFile } from "fs/promises";
-import { createInterface } from "readline";
-import { checkbox, confirm, input, search } from "@inquirer/prompts";
-import pc from "picocolors";
+import { homedir } from "os";
+import path from "path";
+import process2 from "process";
+import { input, select } from "@inquirer/prompts";
+function getConfigPaths() {
+  const home = homedir();
+  const cwd = process2.cwd();
+  const isWin = process2.platform === "win32";
+  const isMac = process2.platform === "darwin";
+  const appData = process2.env.APPDATA || path.join(home, "AppData", "Roaming");
+  let claudeDesktopGlob;
+  if (isWin) {
+    claudeDesktopGlob = path.join(appData, "Claude", "claude_desktop_config.json");
+  } else if (isMac) {
+    claudeDesktopGlob = path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  } else {
+    claudeDesktopGlob = path.join(home, ".config", "Claude", "claude_desktop_config.json");
+  }
+  return [
+    { source: "Cursor (Global)", file: path.join(home, ".cursor", "mcp.json") },
+    { source: "Cursor (Project)", file: path.join(cwd, ".cursor", "mcp.json") },
+    { source: "Windsurf", file: path.join(home, ".codeium", "windsurf", "mcp_config.json") },
+    { source: "Claude Desktop", file: claudeDesktopGlob },
+    { source: "Cline", file: path.join(home, "Documents", "Cline", "MCP", "mcp.json") },
+    { source: "VS Code (Project)", file: path.join(cwd, ".vscode", "mcp.json") },
+    {
+      source: "VS Code (Global)",
+      file: path.join(
+        isMac ? path.join(home, "Library", "Application Support") : isWin ? appData : path.join(home, ".config"),
+        "Code",
+        "User",
+        "settings.json"
+      )
+    },
+    { source: "Copilot CLI (Global)", file: path.join(home, ".copilot", "mcp-config.json") },
+    { source: "Gemini CLI (Global)", file: path.join(home, ".gemini", "settings.json") },
+    { source: "Gemini CLI (Project)", file: path.join(cwd, ".gemini", "settings.json") },
+    { source: "Claude Code (Global)", file: path.join(home, ".claude.json") },
+    { source: "Claude Code (Project)", file: path.join(cwd, ".mcp.json") },
+    { source: "Antigravity", file: path.join(home, ".gemini", "antigravity", "mcp_config.json") }
+  ];
+}
+async function discoverServers() {
+  const servers = [];
+  const paths = getConfigPaths();
+  for (const { source, file } of paths) {
+    if (!existsSync(file)) continue;
+    try {
+      const content = await readFile(file, "utf8");
+      const json = JSON.parse(content);
+      let mcpServers;
+      if (json.mcpServers && typeof json.mcpServers === "object") {
+        mcpServers = json.mcpServers;
+      } else if (json.mcp?.servers && typeof json.mcp.servers === "object") {
+        mcpServers = json.mcp.servers;
+      } else if (json.servers && typeof json.servers === "object") {
+        mcpServers = json.servers;
+      }
+      if (mcpServers) {
+        for (const [name, config] of Object.entries(mcpServers)) {
+          if (config.command) {
+            servers.push({ name, config, source });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return servers;
+}
+async function pickDiscoveredServer() {
+  const servers = await discoverServers();
+  if (servers.length === 0) {
+    return null;
+  }
+  const uniqueServers = /* @__PURE__ */ new Map();
+  for (const s of servers) {
+    const key = `${s.name}::${s.config.command}::${(s.config.args || []).join(" ")}`;
+    if (!uniqueServers.has(key)) {
+      uniqueServers.set(key, s);
+    } else {
+      if (s.source.includes("Project")) {
+        uniqueServers.set(key, s);
+      }
+    }
+  }
+  const choices = Array.from(uniqueServers.values()).map((s) => {
+    return {
+      name: `${s.name} (from ${s.source})`,
+      value: s,
+      description: `${s.config.command} ${(s.config.args || []).join(" ")}`
+    };
+  });
+  choices.push({
+    name: "Enter custom server command...",
+    value: "CUSTOM",
+    description: "Manually specify a command, e.g. 'npx foo' or 'python server.py'"
+  });
+  try {
+    const answer = await select({
+      message: "Select an MCP server to launch:",
+      choices,
+      pageSize: 15
+    });
+    if (answer === "CUSTOM") {
+      const customCommand = await input({ message: "Command to spawn target MCP server:" });
+      if (!customCommand.trim()) return null;
+      const parts = customCommand.trim().match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((p) => p.replace(/^["']|["']$/g, ""));
+      if (!parts || parts.length === 0) return null;
+      return {
+        name: "Custom",
+        config: { command: parts[0], args: parts.slice(1) },
+        source: "Manual"
+      };
+    }
+    return answer;
+  } catch {
+    return null;
+  }
+}
 
 // src/interceptor.ts
 import { mkdir, writeFile } from "fs/promises";
@@ -20,11 +150,13 @@ var ResponseInterceptor = class {
   outDir;
   defaultTimeoutMs;
   maxTextLength;
+  mediaThresholdKb;
   fileCounter = 0;
   constructor(opts = {}) {
     this.outDir = opts.outDir ?? join(tmpdir(), "run-mcp");
     this.defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.maxTextLength = opts.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
+    this.mediaThresholdKb = opts.mediaThresholdKb ?? 0;
   }
   /**
    * Call a tool on the target, applying timeout, media extraction, and truncation.
@@ -32,40 +164,196 @@ var ResponseInterceptor = class {
    * Returns the full result object as-is (including structuredContent, isError, _meta)
    * with only the content array items modified when interception is needed.
    */
-  async callTool(target, name, args = {}, timeoutMs) {
+  async callTool(target, name, args = {}, timeoutMs, maxTextLength) {
+    const { result } = await this._callToolInternal(target, name, args, timeoutMs, maxTextLength);
+    return result;
+  }
+  /**
+   * Call a tool and return both the result and metadata about interception actions.
+   * Used by the agent server when `include_metadata` is requested.
+   */
+  async callToolWithMetadata(target, name, args = {}, timeoutMs, maxTextLength) {
+    return this._callToolInternal(target, name, args, timeoutMs, maxTextLength);
+  }
+  /**
+   * Read a resource on the target, applying timeout, media extraction, and truncation.
+   */
+  async readResource(target, params, timeoutMs, maxTextLength) {
+    const timeout = timeoutMs ?? this.defaultTimeoutMs;
+    const metadata = {
+      truncated: false,
+      imagesSaved: 0,
+      audioSaved: 0,
+      originalSizeBytes: 0
+    };
+    const targetCall = target.readResource(params);
+    targetCall.catch(() => {
+    });
+    const result = await Promise.race([
+      targetCall,
+      this._timeout(timeout, `resource:${params.uri}`)
+    ]);
+    const contents = result.contents;
+    if (Array.isArray(contents)) {
+      for (const item of contents) {
+        if (item.text) {
+          metadata.originalSizeBytes += Buffer.byteLength(item.text, "utf8");
+        } else if (item.blob) {
+          metadata.originalSizeBytes += Buffer.byteLength(item.blob, "base64");
+        }
+      }
+      for (let i = 0; i < contents.length; i++) {
+        contents[i] = await this._processResourceItem(contents[i], metadata, maxTextLength);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get a prompt on the target, applying timeout, media extraction, and truncation.
+   */
+  async getPrompt(target, params, timeoutMs, maxTextLength) {
     const timeout = timeoutMs ?? this.defaultTimeoutMs;
+    const metadata = {
+      truncated: false,
+      imagesSaved: 0,
+      audioSaved: 0,
+      originalSizeBytes: 0
+    };
+    const targetCall = target.getPrompt(params);
+    targetCall.catch(() => {
+    });
+    const result = await Promise.race([
+      targetCall,
+      this._timeout(timeout, `prompt:${params.name}`)
+    ]);
+    const messages = result.messages;
+    if (Array.isArray(messages)) {
+      for (const msg of messages) {
+        const content = msg.content;
+        if (content) {
+          if (Array.isArray(content)) {
+            for (const item of content) {
+              if (item.type === "text" && item.text) {
+                metadata.originalSizeBytes += Buffer.byteLength(item.text, "utf8");
+              } else if ((item.type === "image" || item.type === "audio") && item.data) {
+                metadata.originalSizeBytes += Buffer.byteLength(item.data, "base64");
+              }
+            }
+            for (let i = 0; i < content.length; i++) {
+              content[i] = await this._processItem(content[i], metadata, maxTextLength);
+            }
+          } else if (typeof content === "object") {
+            if (content.type === "text" && content.text) {
+              metadata.originalSizeBytes += Buffer.byteLength(content.text, "utf8");
+            } else if ((content.type === "image" || content.type === "audio") && content.data) {
+              metadata.originalSizeBytes += Buffer.byteLength(content.data, "base64");
+            }
+            msg.content = await this._processItem(content, metadata, maxTextLength);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Internal implementation shared by callTool and callToolWithMetadata.
+   */
+  async _callToolInternal(target, name, args = {}, timeoutMs, maxTextLength) {
+    const timeout = timeoutMs ?? this.defaultTimeoutMs;
+    const metadata = {
+      truncated: false,
+      imagesSaved: 0,
+      audioSaved: 0,
+      originalSizeBytes: 0
+    };
     const targetCall = target.callTool(name, args);
     targetCall.catch(() => {
     });
     const result = await Promise.race([targetCall, this._timeout(timeout, name)]);
     const content = result.content;
     if (Array.isArray(content)) {
+      for (const item of content) {
+        if (item.type === "text" && item.text) {
+          metadata.originalSizeBytes += Buffer.byteLength(item.text, "utf8");
+        } else if ((item.type === "image" || item.type === "audio") && item.data) {
+          metadata.originalSizeBytes += Buffer.byteLength(item.data, "base64");
+        }
+      }
       for (let i = 0; i < content.length; i++) {
-        content[i] = await this._processItem(content[i]);
+        content[i] = await this._processItem(content[i], metadata, maxTextLength);
       }
     }
-    return result;
+    return { result, metadata };
   }
   /**
    * Process a single content item — extract media, truncate text.
    * Preserves all item properties not related to the intercepted data
    * (e.g., annotations, _meta).
    */
-  async _processItem(item) {
+  async _processItem(item, metadata, maxTextLength) {
     if (item.type === "image" && item.data) {
+      const sizeKB = Buffer.byteLength(item.data, "base64") / 1024;
+      if (this.mediaThresholdKb === -1 || this.mediaThresholdKb > 0 && sizeKB <= this.mediaThresholdKb) {
+        return item;
+      }
+      metadata.imagesSaved++;
       return this._saveMedia(item.data, item.mimeType ?? "image/png", "image");
     }
     if (item.type === "audio" && item.data) {
+      const sizeKB = Buffer.byteLength(item.data, "base64") / 1024;
+      if (this.mediaThresholdKb === -1 || this.mediaThresholdKb > 0 && sizeKB <= this.mediaThresholdKb) {
+        return item;
+      }
+      metadata.audioSaved++;
       return this._saveMedia(item.data, item.mimeType ?? "audio/wav", "audio");
     }
     if (item.type === "text" && item.text && BASE64_PATTERN.test(item.text.trim())) {
+      const sizeKB = Buffer.byteLength(item.text.trim(), "base64") / 1024;
+      if (this.mediaThresholdKb === -1 || this.mediaThresholdKb > 0 && sizeKB <= this.mediaThresholdKb) {
+        return item;
+      }
+      metadata.imagesSaved++;
       return this._saveMedia(item.text.trim(), "image/png", "image");
     }
-    if (item.type === "text" && item.text && item.text.length > this.maxTextLength) {
+    const limit = maxTextLength ?? this.maxTextLength;
+    if (item.type === "text" && item.text && limit !== -1 && item.text.length > limit) {
+      const totalLength = item.text.length;
+      metadata.truncated = true;
+      return {
+        ...item,
+        text: item.text.slice(0, limit) + `
+... (truncated, ${totalLength.toLocaleString()} chars total)`
+      };
+    }
+    return item;
+  }
+  /**
+   * Process a single resource content item.
+   */
+  async _processResourceItem(item, metadata, maxTextLength) {
+    if (item.blob) {
+      const mime = item.mimeType ?? "image/png";
+      const isAudio = mime.startsWith("audio/");
+      const sizeKB = Buffer.byteLength(item.blob, "base64") / 1024;
+      if (this.mediaThresholdKb === -1 || this.mediaThresholdKb > 0 && sizeKB <= this.mediaThresholdKb) {
+        return item;
+      }
+      if (isAudio) metadata.audioSaved++;
+      else metadata.imagesSaved++;
+      const saved = await this._saveMedia(item.blob, mime, isAudio ? "audio" : "image");
+      return {
+        uri: item.uri,
+        mimeType: "text/plain",
+        text: saved.text
+      };
+    }
+    const limit = maxTextLength ?? this.maxTextLength;
+    if (item.text && limit !== -1 && item.text.length > limit) {
       const totalLength = item.text.length;
+      metadata.truncated = true;
       return {
         ...item,
-        text: item.text.slice(0, this.maxTextLength) + `
+        text: item.text.slice(0, limit) + `
 ... (truncated, ${totalLength.toLocaleString()} chars total)`
       };
     }
@@ -95,13 +383,14 @@ var ResponseInterceptor = class {
   /**
    * Returns a promise that rejects after the given timeout.
    */
-  _timeout(ms, toolName) {
+  _timeout(ms, targetName) {
     return new Promise((_, reject) => {
       setTimeout(() => {
         const humanMs = ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${ms}ms`;
+        const typeLabel2 = targetName.includes(":") ? "Request" : "Tool";
         reject(
           new Error(
-            `Tool "${toolName}" timed out after ${ms}ms (${humanMs}). Use --timeout <ms> to increase the limit.`
+            `${typeLabel2} "${targetName}" timed out after ${ms}ms (${humanMs}). Use --timeout <ms> to increase the limit.`
           )
         );
       }, ms);
@@ -135,6 +424,7 @@ var ResponseInterceptor = class {
 };
 
 // src/parsing.ts
+import pc from "picocolors";
 function parseCommandLine(input3) {
   const spaceIdx = input3.indexOf(" ");
   if (spaceIdx === -1) {
@@ -162,9 +452,92 @@ function parseCallArgs(rest) {
   }
   return { toolName, jsonArgs: remainder, timeoutMs };
 }
-function formatJson(obj, indent = 2) {
+function formatJson(obj, indent = 2, colorize = false) {
   const json = JSON.stringify(obj, null, indent);
-  return json.split("\n").map((line) => " ".repeat(indent) + line).join("\n");
+  const output = colorize ? colorizeJson(json) : json;
+  return output.split("\n").map((line) => " ".repeat(indent) + line).join("\n");
+}
+function colorizeJson(json) {
+  const result = [];
+  let i = 0;
+  let expectingValue = false;
+  while (i < json.length) {
+    const ch = json[i];
+    if (ch === '"') {
+      const str = consumeString(json, i);
+      if (expectingValue) {
+        result.push(pc.green(str));
+        expectingValue = false;
+      } else {
+        result.push(pc.cyan(str));
+      }
+      i += str.length;
+      continue;
+    }
+    if (ch === ":") {
+      result.push(ch);
+      expectingValue = true;
+      i++;
+      continue;
+    }
+    if (ch === "," || ch === "}" || ch === "]") {
+      result.push(ch);
+      expectingValue = false;
+      i++;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      result.push(ch);
+      if (ch === "[") expectingValue = true;
+      i++;
+      continue;
+    }
+    if (json.startsWith("true", i)) {
+      result.push(pc.magenta("true"));
+      expectingValue = false;
+      i += 4;
+      continue;
+    }
+    if (json.startsWith("false", i)) {
+      result.push(pc.magenta("false"));
+      expectingValue = false;
+      i += 5;
+      continue;
+    }
+    if (json.startsWith("null", i)) {
+      result.push(pc.dim("null"));
+      expectingValue = false;
+      i += 4;
+      continue;
+    }
+    if (ch === "-" || ch >= "0" && ch <= "9") {
+      let num = "";
+      while (i < json.length && /[0-9.eE+-]/.test(json[i])) {
+        num += json[i];
+        i++;
+      }
+      result.push(pc.yellow(num));
+      expectingValue = false;
+      continue;
+    }
+    result.push(ch);
+    i++;
+  }
+  return result.join("");
+}
+function consumeString(json, start) {
+  let i = start + 1;
+  while (i < json.length) {
+    if (json[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (json[i] === '"') {
+      return json.slice(start, i + 1);
+    }
+    i++;
+  }
+  return json.slice(start);
 }
 function levenshtein(a, b) {
   const m = a.length;
@@ -198,6 +571,13 @@ function scaffoldArgs(schema) {
   return JSON.stringify(scaffoldObject(schema), null, 2);
 }
 function scaffoldValue(prop) {
+  if (Array.isArray(prop.enum) && prop.enum.length > 0) {
+    return prop.enum[0];
+  }
+  const variants = prop.anyOf ?? prop.oneOf;
+  if (Array.isArray(variants) && variants.length > 0) {
+    return scaffoldValue(variants[0]);
+  }
   switch (prop.type) {
     case "string":
       return "<string>";
@@ -218,12 +598,21 @@ function scaffoldValue(prop) {
 }
 function scaffoldObject(schema) {
   const properties = schema.properties;
-  if (!properties) return {};
-  const result = {};
-  for (const [key, prop] of Object.entries(properties)) {
-    result[key] = scaffoldValue(prop);
+  if (properties) {
+    const result = {};
+    for (const [key, prop] of Object.entries(properties)) {
+      result[key] = scaffoldValue(prop);
+    }
+    return result;
   }
-  return result;
+  const additionalProperties = schema.additionalProperties;
+  if (additionalProperties && typeof additionalProperties === "object") {
+    return { "<key>": scaffoldValue(additionalProperties) };
+  }
+  if (additionalProperties === true || schema.type === "object" && !properties) {
+    return { "<key>": "<value>" };
+  }
+  return {};
 }
 function formatToolDescription(tool) {
   const lines = [];
@@ -259,14 +648,15 @@ function formatToolDescription(tool) {
   } else {
     lines.push(`    tools/call ${tool.name}`);
   }
-  if (tool.annotations && Object.keys(tool.annotations).length > 0) {
-    lines.push("");
-    lines.push("  Annotations:");
-    const annotationParts = [];
-    for (const [key, value] of Object.entries(tool.annotations)) {
-      annotationParts.push(`${key}: ${value}`);
+  if (tool.annotations) {
+    const entries = Object.entries(tool.annotations).filter(([key]) => key !== "title");
+    if (entries.length > 0) {
+      lines.push("");
+      lines.push("  Annotations:");
+      for (const [key, value] of entries) {
+        lines.push(`    ${key}: ${value}`);
+      }
     }
-    lines.push(`    ${annotationParts.join(", ")}`);
   }
   return lines.join("\n");
 }
@@ -340,9 +730,111 @@ function resolveAlias(input3) {
   if (!expanded) return null;
   return expanded + rest;
 }
+function splitArgs(input3) {
+  const tokens = [];
+  let current = "";
+  let inDoubleQuote = false;
+  let inSingleQuote = false;
+  let escape = false;
+  for (let i = 0; i < input3.length; i++) {
+    const ch = input3[i];
+    if (escape) {
+      current += ch;
+      escape = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escape = true;
+      continue;
+    }
+    if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += ch;
+      continue;
+    }
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += ch;
+      continue;
+    }
+    if (ch === " " && !inDoubleQuote && !inSingleQuote) {
+      if (current.trim()) {
+        tokens.push(current.trim());
+      }
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    tokens.push(current.trim());
+  }
+  return tokens;
+}
+function parseHttpieArgs(argsString) {
+  const result = {};
+  const trimmedArgs = argsString.trim();
+  if (!trimmedArgs) return result;
+  const tokens = splitArgs(trimmedArgs);
+  for (const token of tokens) {
+    const eqIdx = token.indexOf("=");
+    if (eqIdx === -1) continue;
+    const isJson = eqIdx > 0 && token[eqIdx - 1] === ":";
+    const key = isJson ? token.slice(0, eqIdx - 1).trim() : token.slice(0, eqIdx).trim();
+    let rawVal = token.slice(eqIdx + 1).trim();
+    if (rawVal.startsWith('"') && rawVal.endsWith('"') || rawVal.startsWith("'") && rawVal.endsWith("'")) {
+      rawVal = rawVal.slice(1, -1);
+    }
+    if (isJson) {
+      try {
+        result[key] = JSON.parse(rawVal);
+      } catch {
+        result[key] = rawVal;
+      }
+    } else {
+      result[key] = rawVal;
+    }
+  }
+  return result;
+}
+function resolveJsonPath(obj, path2) {
+  const parts = path2.replace(/\["([^"]+)"\]/g, ".$1").replace(/\['([^']+)'\]/g, ".$1").replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current === void 0 || current === null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function interpolateString(input3, context) {
+  const regex = /\$([a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])?((?:\.[a-zA-Z0-9_]+|\[\d+\]|\["[^"]+"\]|\['[^']+'\])*)/g;
+  return input3.replace(regex, (match, root, path2) => {
+    let baseName = root;
+    let fullPath = path2 || "";
+    if (baseName && baseName.startsWith("[")) {
+      fullPath = baseName + fullPath;
+      baseName = "LAST";
+    }
+    if (!baseName) {
+      baseName = "LAST";
+    }
+    if (!(baseName in context)) {
+      return match;
+    }
+    const value = resolveJsonPath(context[baseName], fullPath);
+    if (value === void 0) {
+      return match;
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  });
+}
 
 // src/target-manager.ts
 import { EventEmitter } from "events";
+import treeKill from "tree-kill";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -382,6 +874,7 @@ var TargetManager = class _TargetManager extends EventEmitter {
   _autoReconnect = false;
   _reconnecting = false;
   _intentionalClose = false;
+  _everConnected = false;
   // Request history
   _history = [];
   _historyIdCounter = 0;
@@ -403,146 +896,154 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async connect() {
     this._intentionalClose = false;
-    if (this.command.startsWith("http://") || this.command.startsWith("https://")) {
-      this.transport = new SSEClientTransport(new URL(this.command));
-    } else {
-      const stdioTransport = new StdioClientTransport({
-        command: this.command,
-        args: this.args,
-        stderr: "pipe"
-      });
-      stdioTransport.stderr?.on("data", (chunk) => {
-        const text = chunk.toString().trimEnd();
-        if (text) {
-          const lines = text.split("\n");
-          this._stderrLineCount += lines.length;
-          this._stderrLines.push(...lines);
-          if (this._stderrLines.length > _TargetManager.MAX_STDERR_LINES) {
-            this._stderrLines = this._stderrLines.slice(-_TargetManager.MAX_STDERR_LINES);
+    this._everConnected = false;
+    try {
+      if (this.command.startsWith("http://") || this.command.startsWith("https://")) {
+        this.transport = new SSEClientTransport(new URL(this.command));
+      } else {
+        const stdioTransport = new StdioClientTransport({
+          command: this.command,
+          args: this.args,
+          stderr: "pipe"
+        });
+        stdioTransport.stderr?.on("data", (chunk) => {
+          const text = chunk.toString().trimEnd();
+          if (text) {
+            const lines = text.split("\n");
+            this._stderrLineCount += lines.length;
+            this._stderrLines.push(...lines);
+            if (this._stderrLines.length > _TargetManager.MAX_STDERR_LINES) {
+              this._stderrLines = this._stderrLines.slice(-_TargetManager.MAX_STDERR_LINES);
+            }
+            this.emit("stderr", text);
+          }
+        });
+        this.transport = stdioTransport;
+      }
+      this.client = new Client(
+        { name: "run-mcp", version: "1.6.1" },
+        {
+          capabilities: {
+            roots: { listChanged: true },
+            sampling: {},
+            elicitation: {}
           }
-          this.emit("stderr", text);
         }
-      });
-      this.transport = stdioTransport;
-    }
-    this.client = new Client(
-      { name: "run-mcp", version: "1.4.0" },
-      {
-        capabilities: {
-          roots: { listChanged: true },
-          sampling: {},
-          elicitation: {}
+      );
+      this.client.setNotificationHandler(
+        LoggingMessageNotificationSchema,
+        async (notification) => {
+          const record = {
+            method: "notifications/message",
+            params: notification.params,
+            timestamp: Date.now()
+          };
+          this._pushNotification(record);
+          this.emit("notification", record);
         }
-      }
-    );
-    this.client.setNotificationHandler(
-      LoggingMessageNotificationSchema,
-      async (notification) => {
+      );
+      this.client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
         const record = {
-          method: "notifications/message",
-          params: notification.params,
+          method: "notifications/tools/list_changed",
           timestamp: Date.now()
         };
         this._pushNotification(record);
         this.emit("notification", record);
-      }
-    );
-    this.client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
-      const record = {
-        method: "notifications/tools/list_changed",
-        timestamp: Date.now()
-      };
-      this._pushNotification(record);
-      this.emit("notification", record);
-    });
-    this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
-      const record = {
-        method: "notifications/resources/list_changed",
-        timestamp: Date.now()
-      };
-      this._pushNotification(record);
-      this.emit("notification", record);
-    });
-    this.client.setNotificationHandler(
-      ResourceUpdatedNotificationSchema,
-      async (notification) => {
+      });
+      this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
         const record = {
-          method: "notifications/resources/updated",
-          params: notification.params,
+          method: "notifications/resources/list_changed",
           timestamp: Date.now()
         };
         this._pushNotification(record);
         this.emit("notification", record);
-      }
-    );
-    this.client.setNotificationHandler(PromptListChangedNotificationSchema, async () => {
-      const record = {
-        method: "notifications/prompts/list_changed",
-        timestamp: Date.now()
-      };
-      this._pushNotification(record);
-      this.emit("notification", record);
-    });
-    this.client.setRequestHandler(CreateMessageRequestSchema, async (request) => {
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Sampling request timed out (no response from user in 5 minutes)"));
-        }, 3e5);
-        this.emit("sampling_request", {
-          request: request.params,
-          respond: (result) => {
-            clearTimeout(timeout);
-            resolve(result);
-          },
-          reject: (err) => {
-            clearTimeout(timeout);
-            reject(err);
-          }
+      });
+      this.client.setNotificationHandler(
+        ResourceUpdatedNotificationSchema,
+        async (notification) => {
+          const record = {
+            method: "notifications/resources/updated",
+            params: notification.params,
+            timestamp: Date.now()
+          };
+          this._pushNotification(record);
+          this.emit("notification", record);
+        }
+      );
+      this.client.setNotificationHandler(PromptListChangedNotificationSchema, async () => {
+        const record = {
+          method: "notifications/prompts/list_changed",
+          timestamp: Date.now()
+        };
+        this._pushNotification(record);
+        this.emit("notification", record);
+      });
+      this.client.setRequestHandler(CreateMessageRequestSchema, async (request) => {
+        return new Promise((resolve2, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("Sampling request timed out (no response from user in 5 minutes)"));
+          }, 3e5);
+          this.emit("sampling_request", {
+            request: request.params,
+            respond: (result) => {
+              clearTimeout(timeout);
+              resolve2(result);
+            },
+            reject: (err) => {
+              clearTimeout(timeout);
+              reject(err);
+            }
+          });
         });
       });
-    });
-    this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Elicitation request timed out (no response from user in 5 minutes)"));
-        }, 3e5);
-        this.emit("elicitation_request", {
-          request: request.params,
-          respond: (result) => {
-            clearTimeout(timeout);
-            resolve(result);
-          },
-          reject: (err) => {
-            clearTimeout(timeout);
-            reject(err);
-          }
+      this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
+        return new Promise((resolve2, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("Elicitation request timed out (no response from user in 5 minutes)"));
+          }, 3e5);
+          this.emit("elicitation_request", {
+            request: request.params,
+            respond: (result) => {
+              clearTimeout(timeout);
+              resolve2(result);
+            },
+            reject: (err) => {
+              clearTimeout(timeout);
+              reject(err);
+            }
+          });
         });
       });
-    });
-    this.client.setRequestHandler(ListRootsRequestSchema, async () => {
-      return { roots: this._roots };
-    });
-    this.client.onclose = () => {
-      this._connected = false;
-      this._clearStableTimer();
-      if (this._intentionalClose) {
-        return;
+      this.client.setRequestHandler(ListRootsRequestSchema, async () => {
+        return { roots: this._roots };
+      });
+      this.client.onclose = () => {
+        this._connected = false;
+        this._clearStableTimer();
+        if (this._intentionalClose || !this._everConnected) {
+          return;
+        }
+        this.emit("disconnected");
+        this._maybeReconnect();
+      };
+      await this.client.connect(this.transport);
+      this._connected = true;
+      this._everConnected = true;
+      this.startTime = Date.now();
+      const proc = this.transport._process;
+      if (proc?.pid) {
+        this.childPid = proc.pid;
+      } else {
+        this.childPid = null;
       }
-      this.emit("disconnected");
-      this._maybeReconnect();
-    };
-    await this.client.connect(this.transport);
-    this._connected = true;
-    this.startTime = Date.now();
-    const proc = this.transport._process;
-    if (proc?.pid) {
-      this.childPid = proc.pid;
-    } else {
-      this.childPid = null;
+      this.emit("connected");
+      this._registerCleanup();
+      this._startStableTimer();
+    } catch (err) {
+      await this.close().catch(() => {
+      });
+      throw err;
     }
-    this.emit("connected");
-    this._registerCleanup();
-    this._startStableTimer();
   }
   get connected() {
     return this._connected;
@@ -846,11 +1347,12 @@ var TargetManager = class _TargetManager extends EventEmitter {
     };
   }
   /**
-   * Cleanly shut down the client connection and child process.
+   * Cleanly shut down the client connection and forcefully kill the child process tree.
    */
   async close() {
     this._intentionalClose = true;
     this._clearStableTimer();
+    const pidToKill = this.childPid;
     if (this.client) {
       try {
         await this.client.close();
@@ -865,6 +1367,11 @@ var TargetManager = class _TargetManager extends EventEmitter {
       }
       this.transport = null;
     }
+    if (pidToKill) {
+      await new Promise((resolve2) => {
+        treeKill(pidToKill, "SIGKILL", () => resolve2());
+      });
+    }
     this._connected = false;
     this.childPid = null;
   }
@@ -965,7 +1472,153 @@ var TargetManager = class _TargetManager extends EventEmitter {
   }
 };
 
+// src/headless.ts
+var DEFAULT_HEADLESS_TIMEOUT_MS = 3e4;
+async function runHeadless(targetCommand, operation, opts = {}) {
+  const [command, ...args] = targetCommand;
+  const target = new TargetManager(command, args);
+  const interceptor = new ResponseInterceptor({
+    outDir: opts.outDir,
+    defaultTimeoutMs: opts.timeoutMs ?? DEFAULT_HEADLESS_TIMEOUT_MS
+  });
+  if (opts.showStderr) {
+    target.on("stderr", (text) => {
+      process.stderr.write(`${text}
+`);
+    });
+  } else {
+    target.on("stderr", () => {
+    });
+  }
+  try {
+    process.stderr.write(`Connecting to ${targetCommand.join(" ")}...
+`);
+    await target.connect();
+    const status = target.getStatus();
+    process.stderr.write(`Connected (PID: ${status.pid})
+`);
+    const { result, hasError } = await executeOperation(target, interceptor, operation, opts);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    await target.close();
+    process.exit(hasError ? 1 : 0);
+  } catch (err) {
+    const msg = err.message ?? String(err);
+    if (msg.includes("ENOENT") || msg.includes("spawn")) {
+      process.stderr.write(
+        `Error: command "${command}" not found. Check that it is installed and in your PATH.
+`
+      );
+    } else if (msg.includes("timed out")) {
+      process.stderr.write(`Error: ${msg}
+`);
+    } else {
+      process.stderr.write(`Error: ${msg}
+`);
+    }
+    await target.close().catch(() => {
+    });
+    process.exit(1);
+  }
+}
+async function executeOperation(target, interceptor, operation, opts) {
+  switch (operation.type) {
+    case "call": {
+      let parsedArgs = {};
+      if (operation.args) {
+        const trimmed = operation.args.trim();
+        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          try {
+            parsedArgs = JSON.parse(trimmed);
+          } catch (err) {
+            process.stderr.write(`Error: Invalid JSON arguments: ${err.message}
+`);
+            process.stderr.write(`  Received: ${operation.args}
+`);
+            process.exit(2);
+          }
+        } else {
+          parsedArgs = parseHttpieArgs(trimmed);
+        }
+      }
+      const result = await interceptor.callTool(target, operation.tool, parsedArgs);
+      if (result.isError) {
+        const content = result.content;
+        if (Array.isArray(content)) {
+          const errorText = content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+          if (errorText) {
+            process.stderr.write(`Tool error: ${errorText}
+`);
+          }
+        }
+        if (opts.raw) return { result, hasError: true };
+        return { result: result.content ?? result, hasError: true };
+      }
+      if (opts.raw) return { result, hasError: false };
+      return { result: result.content ?? result, hasError: false };
+    }
+    case "list-tools": {
+      const { tools } = await target.listTools();
+      return { result: tools, hasError: false };
+    }
+    case "list-resources": {
+      const { resources } = await target.listResources();
+      return { result: resources, hasError: false };
+    }
+    case "list-prompts": {
+      const { prompts } = await target.listPrompts();
+      return { result: prompts, hasError: false };
+    }
+    case "read": {
+      const result = await interceptor.readResource(target, { uri: operation.uri });
+      return { result, hasError: false };
+    }
+    case "describe": {
+      const { tools } = await target.listTools();
+      const tool = tools.find((t) => t.name === operation.tool);
+      if (!tool) {
+        const available = tools.map((t) => t.name).join(", ");
+        process.stderr.write(
+          `Error: Tool "${operation.tool}" not found.
+Available tools: ${available}
+`
+        );
+        process.exit(1);
+      }
+      return { result: tool, hasError: false };
+    }
+    case "get-prompt": {
+      let parsedArgs;
+      if (operation.args) {
+        const trimmed = operation.args.trim();
+        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          try {
+            parsedArgs = JSON.parse(trimmed);
+          } catch (err) {
+            process.stderr.write(`Error: Invalid JSON arguments: ${err.message}
+`);
+            process.stderr.write(`  Received: ${operation.args}
+`);
+            process.exit(2);
+          }
+        } else {
+          parsedArgs = parseHttpieArgs(trimmed);
+        }
+      }
+      const result = await interceptor.getPrompt(target, {
+        name: operation.name,
+        arguments: parsedArgs
+      });
+      return { result, hasError: false };
+    }
+  }
+}
+
 // src/repl.ts
+import { readFile as readFile2 } from "fs/promises";
+import { createInterface } from "readline";
+import { checkbox, confirm, input as input2, search } from "@inquirer/prompts";
+import pc2 from "picocolors";
 var KNOWN_COMMANDS = [
   "explore",
   "interactive",
@@ -994,6 +1647,7 @@ var KNOWN_COMMANDS = [
   "!!",
   "last",
   "help",
+  "?",
   "exit",
   "quit",
   // Short aliases
@@ -1012,8 +1666,22 @@ var KNOWN_COMMANDS = [
 var cachedToolNames = [];
 var cachedResourceUris = [];
 var cachedPromptNames = [];
+var activeCapabilities = null;
+function getActiveCommands() {
+  let commands = [...KNOWN_COMMANDS];
+  if (!activeCapabilities?.resources) {
+    commands = commands.filter(
+      (c) => !c.startsWith("resources/") && !["rl", "rr", "rt", "rs", "ru"].includes(c)
+    );
+  }
+  if (!activeCapabilities?.prompts) {
+    commands = commands.filter((c) => !c.startsWith("prompts/") && !["pl", "pg"].includes(c));
+  }
+  return commands;
+}
 async function refreshCaches(target) {
   const caps = target.getServerCapabilities() ?? {};
+  activeCapabilities = caps;
   try {
     const { tools } = await target.listTools();
     cachedToolNames = tools.map((t) => t.name);
@@ -1058,7 +1726,7 @@ function computeMatches(line) {
     const matches2 = cachedPromptNames.filter((n) => n.startsWith(partial));
     return [matches2.map((m) => `prompts/get ${m}`), effective];
   }
-  const matches = KNOWN_COMMANDS.filter((c) => c.startsWith(line));
+  const matches = getActiveCommands().filter((c) => c.startsWith(line));
   return [matches, line];
 }
 var completer = (line) => {
@@ -1122,34 +1790,36 @@ async function withSuspendedReadline(target, interceptor, fn) {
   }
 }
 function getPrompt(target) {
-  if (target.connected) return `${pc.green("\u2713")}${pc.cyan("> ")}`;
-  return `${pc.red("\u2717")}${pc.cyan("> ")}`;
+  if (target.connected) return `${pc2.green("\u2713")}${pc2.cyan("> ")}`;
+  return `${pc2.red("\u2717")}${pc2.cyan("> ")}`;
 }
 function printBanner(serverName, serverVersion, toolCount, resourceCount, promptCount) {
   const parts = [];
-  parts.push(`${pc.bold(toolCount.toString())} tools`);
-  if (resourceCount > 0) parts.push(`${pc.bold(resourceCount.toString())} resources`);
-  if (promptCount > 0) parts.push(`${pc.bold(promptCount.toString())} prompts`);
-  const title = serverVersion ? `${serverName} ${pc.dim(`v${serverVersion}`)}` : serverName;
+  parts.push(`${pc2.bold(toolCount.toString())} tools`);
+  if (resourceCount > 0) parts.push(`${pc2.bold(resourceCount.toString())} resources`);
+  if (promptCount > 0) parts.push(`${pc2.bold(promptCount.toString())} prompts`);
+  const baseTitle = serverVersion ? `${serverName} ${pc2.dim(`v${serverVersion}`)}` : serverName;
+  const isAgentHarness = serverName === "run-mcp";
+  const title = isAgentHarness ? `${baseTitle} ${pc2.bgBlue(pc2.white(" AGENT HARNESS "))}` : baseTitle;
   const BOX_WIDTH = 53;
   const padLine = (content) => {
     const visible = stripAnsi(content).length;
     const padding = Math.max(0, BOX_WIDTH - visible);
-    return `${pc.cyan("  \u2502")}${content}${"".padEnd(padding)}${pc.cyan("\u2502")}`;
+    return `${pc2.cyan("  \u2502")}${content}${"".padEnd(padding)}${pc2.cyan("\u2502")}`;
   };
   const partsStr = `  ${parts.join(" \u2022 ")}`;
   console.log();
-  console.log(pc.cyan(`  \u250C${"\u2500".repeat(BOX_WIDTH)}\u2510`));
+  console.log(pc2.cyan(`  \u250C${"\u2500".repeat(BOX_WIDTH)}\u2510`));
   console.log(padLine(`  ${title}`));
   console.log(padLine(partsStr));
-  console.log(pc.cyan(`  \u251C${"\u2500".repeat(BOX_WIDTH)}\u2524`));
+  console.log(pc2.cyan(`  \u251C${"\u2500".repeat(BOX_WIDTH)}\u2524`));
   console.log(padLine("  Quick start:"));
-  console.log(padLine(`    ${pc.green("tools/list")}                  See all tools`));
-  console.log(padLine(`    ${pc.green("tools/call")} ${pc.dim("<name>")}           Call a tool`));
-  console.log(padLine(`    ${pc.green("help")}                        All commands`));
+  console.log(padLine(`    ${pc2.green("tools/list")}                  See all tools`));
+  console.log(padLine(`    ${pc2.green("tools/call")} ${pc2.dim("<name>")}           Call a tool`));
+  console.log(padLine(`    ${pc2.green("help")}                        All commands`));
   console.log(padLine(""));
-  console.log(padLine(pc.dim("  Tab completion is active. Start typing to explore.")));
-  console.log(pc.cyan(`  \u2514${"\u2500".repeat(BOX_WIDTH)}\u2518`));
+  console.log(padLine(pc2.dim("  Tab completion is active. Start typing to explore.")));
+  console.log(pc2.cyan(`  \u2514${"\u2500".repeat(BOX_WIDTH)}\u2518`));
   console.log();
 }
 function stripAnsi(str) {
@@ -1158,51 +1828,54 @@ function stripAnsi(str) {
 async function startRepl(targetCommand, opts) {
   const [command, ...args] = targetCommand;
   const target = new TargetManager(command, args);
-  const interceptor = new ResponseInterceptor({ outDir: opts.outDir });
+  const interceptor = new ResponseInterceptor({
+    outDir: opts.outDir,
+    mediaThresholdKb: opts.mediaThresholdKb
+  });
   isScriptMode = !!opts.script;
   target.on("stderr", (text) => {
     for (const line of text.split("\n")) {
-      console.error(pc.dim(`[server] ${line}`));
+      console.error(pc2.dim(`[server] ${line}`));
     }
   });
-  console.log(pc.cyan("\u27F3 Connecting to target MCP server..."));
-  console.log(pc.dim(`  Command: ${targetCommand.join(" ")}`));
+  console.log(pc2.cyan("\u27F3 Connecting to target MCP server..."));
+  console.log(pc2.dim(`  Command: ${targetCommand.join(" ")}`));
   try {
     await target.connect();
   } catch (err) {
     const msg = err.message ?? String(err);
     if (msg.includes("ENOENT") || msg.includes("spawn")) {
-      console.error(pc.red(`\u2717 Failed to start server: command "${command}" not found.`));
-      console.error(pc.dim(`  Check that "${command}" is installed and in your PATH.`));
+      console.error(pc2.red(`\u2717 Failed to start server: command "${command}" not found.`));
+      console.error(pc2.dim(`  Check that "${command}" is installed and in your PATH.`));
     } else {
-      console.error(pc.red(`\u2717 Failed to connect: ${msg}`));
-      console.error(pc.dim(`  Check that the target command starts a valid MCP server on stdio.`));
+      console.error(pc2.red(`\u2717 Failed to connect: ${msg}`));
+      console.error(pc2.dim(`  Check that the target command starts a valid MCP server on stdio.`));
     }
     process.exit(1);
   }
   const status = target.getStatus();
-  console.log(pc.green(`\u2713 Connected (PID: ${status.pid})`));
+  console.log(pc2.green(`\u2713 Connected (PID: ${status.pid})`));
   if (!isScriptMode) {
     target.enableAutoReconnect();
     target.on(
       "reconnecting",
       ({ attempt, maxAttempts }) => {
         console.log(
-          pc.yellow(`
+          pc2.yellow(`
 \u27F3 Server disconnected. Reconnecting (${attempt}/${maxAttempts})...`)
         );
       }
     );
     target.on("reconnected", async ({ attempt }) => {
       const s = target.getStatus();
-      console.log(pc.green(`\u2713 Reconnected (PID: ${s.pid}, attempt ${attempt})`));
+      console.log(pc2.green(`\u2713 Reconnected (PID: ${s.pid}, attempt ${attempt})`));
       await refreshCaches(target);
     });
     target.on("reconnect_failed", ({ reason, message }) => {
-      console.error(pc.red(`\u2717 ${message}`));
+      console.error(pc2.red(`\u2717 ${message}`));
       if (reason === "max_retries") {
         console.log(
-          pc.dim("  Use 'exit' to quit or wait for the server to be fixed and restart manually.")
+          pc2.dim("  Use 'exit' to quit or wait for the server to be fixed and restart manually.")
         );
       }
     });
@@ -1212,38 +1885,38 @@ async function startRepl(targetCommand, opts) {
         const lvl = notification.params?.level ?? "info";
         const data = notification.params?.data ?? "";
         const text = typeof data === "string" ? data : JSON.stringify(data);
-        console.log(pc.dim(`
+        console.log(pc2.dim(`
   [${lvl}] ${text}`));
       } else if (method === "notifications/tools/list_changed") {
-        console.log(pc.yellow("\n  \u27F3 Server tools changed. Run tools/list to see updates."));
+        console.log(pc2.yellow("\n  \u27F3 Server tools changed. Run tools/list to see updates."));
         refreshCaches(target).catch(() => {
         });
       } else if (method === "notifications/resources/list_changed") {
-        console.log(pc.yellow("\n  \u27F3 Server resources changed. Run resources/list to see."));
+        console.log(pc2.yellow("\n  \u27F3 Server resources changed. Run resources/list to see."));
         refreshCaches(target).catch(() => {
         });
       } else if (method === "notifications/resources/updated") {
         const uri = notification.params?.uri ?? "unknown";
-        console.log(pc.yellow(`
+        console.log(pc2.yellow(`
   \u27F3 Resource updated: ${uri}`));
       } else if (method === "notifications/prompts/list_changed") {
-        console.log(pc.yellow("\n  \u27F3 Server prompts changed. Run prompts/list to see."));
+        console.log(pc2.yellow("\n  \u27F3 Server prompts changed. Run prompts/list to see."));
         refreshCaches(target).catch(() => {
         });
       }
     });
     target.on("sampling_request", async ({ request, respond, reject: rejectFn }) => {
-      console.log(pc.magenta("\n  \u2554\u2550\u2550 Sampling Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      console.log(pc2.magenta("\n  \u2554\u2550\u2550 Sampling Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
       const messages = request?.messages ?? [];
       for (const msg of messages) {
-        const role = msg.role === "user" ? pc.blue("user") : pc.magenta("assistant");
+        const role = msg.role === "user" ? pc2.blue("user") : pc2.magenta("assistant");
         const text = msg.content?.text ?? JSON.stringify(msg.content);
-        console.log(pc.magenta(`  \u2551 ${role}: ${text}`));
+        console.log(pc2.magenta(`  \u2551 ${role}: ${text}`));
       }
-      console.log(pc.magenta("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      console.log(pc2.magenta("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
       if (activeRl) {
         try {
-          const answer = await question(activeRl, `  ${pc.bold("Approve? [y/N/text]:")} `);
+          const answer = await question(activeRl, `  ${pc2.bold("Approve? [y/N/text]:")} `);
           const trimmed = answer.trim().toLowerCase();
           if (trimmed === "y" || trimmed === "yes") {
             respond({
@@ -1272,14 +1945,14 @@ async function startRepl(targetCommand, opts) {
       }
     });
     target.on("elicitation_request", async ({ request, respond, reject: rejectFn }) => {
-      console.log(pc.cyan("\n  \u2554\u2550\u2550 Elicitation Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-      console.log(pc.cyan(`  \u2551 ${request?.message ?? "Server requests input"}`));
-      console.log(pc.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      console.log(pc2.cyan("\n  \u2554\u2550\u2550 Elicitation Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      console.log(pc2.cyan(`  \u2551 ${request?.message ?? "Server requests input"}`));
+      console.log(pc2.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
       if (activeRl) {
         try {
           const answer = await question(
             activeRl,
-            `  ${pc.bold("Your response (empty to decline):")} `
+            `  ${pc2.bold("Your response (empty to decline):")} `
           );
           if (answer.trim() === "") {
             respond({ action: "decline" });
@@ -1303,7 +1976,7 @@ async function startRepl(targetCommand, opts) {
       }
     });
   }
-  let toolCount = 0;
+  let toolCount;
   let resourceCount = 0;
   let promptCount = 0;
   try {
@@ -1334,31 +2007,74 @@ async function startRepl(targetCommand, opts) {
       );
       if (!groups.has("All")) {
         for (const [label, members] of groups) {
-          console.log(`  ${pc.bold(label.padEnd(16))} ${pc.dim(members.join(", "))}`);
+          console.log(`  ${pc2.bold(label.padEnd(16))} ${pc2.dim(members.join(", "))}`);
         }
         console.log();
       }
     }
   } catch (err) {
-    console.log(pc.yellow(`  Warning: Could not list tools: ${err.message}
+    console.log(pc2.yellow(`  Warning: Could not list tools: ${err.message}
 `));
   }
   await refreshCaches(target);
   if (isScriptMode) {
     const lines = await readScriptLines(opts.script);
+    const scriptContext = {};
+    let expectError = false;
     for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
+      let trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        if (trimmed === "# @expect-error") {
+          expectError = true;
+        }
+        continue;
+      }
+      if (trimmed.endsWith("# @expect-error")) {
+        expectError = true;
+        trimmed = trimmed.replace(/\s*#\s*@expect-error$/, "");
+      }
+      const interpolated = interpolateString(trimmed, scriptContext);
       try {
-        await handleCommand(trimmed, target, interceptor);
+        const res = await handleCommand(interpolated, target, interceptor);
+        if (res !== void 0) {
+          scriptContext.LAST = res;
+        }
+        const isErrorRes = res && typeof res === "object" && res.isError === true;
+        if (expectError && !isErrorRes) {
+          console.error(pc2.red(`\u2717 Expected an error but the command succeeded.`));
+          await target.close();
+          process.exit(1);
+        }
+        if (!expectError && isErrorRes) {
+          console.error(pc2.red(`\u2717 Command failed unexpectedly.`));
+          await target.close();
+          process.exit(1);
+        }
+        if (expectError && isErrorRes) {
+          console.log(pc2.yellow(`  \u2713 Expected error caught: tool returned isError: true`));
+        }
       } catch (err) {
-        console.error(pc.red(`\u2717 Error: ${err.message}`));
-        console.log(pc.dim("\nShutting down..."));
-        await target.close();
-        process.exit(1);
+        if (expectError) {
+          console.log(pc2.yellow(`  \u2713 Expected error caught: ${err.message}`));
+        } else {
+          if (err?.message?.includes("-32601") || err?.code === -32601) {
+            let msg = "Server does not support this feature (Method not found)";
+            if (trimmed.startsWith("prompts/")) msg = "This server does not have any prompts.";
+            else if (trimmed.startsWith("resources/"))
+              msg = "This server does not have any resources.";
+            else if (trimmed.startsWith("tools/")) msg = "This server does not have any tools.";
+            console.log(pc2.yellow(`  ${msg}`));
+          } else {
+            console.error(pc2.red(`\u2717 Error: ${err.message}`));
+          }
+          console.log(pc2.dim("\nShutting down..."));
+          await target.close();
+          process.exit(1);
+        }
       }
+      expectError = false;
     }
-    console.log(pc.dim("\nShutting down..."));
+    console.log(pc2.dim("\nShutting down..."));
     await target.close();
     process.exit(0);
   } else {
@@ -1400,9 +2116,16 @@ function startReadlineLoop(target, interceptor) {
         await handleCommand(trimmed, target, interceptor);
       } catch (err) {
         if (err instanceof AbortFlowError) {
-          console.log(pc.yellow("  Aborted."));
+          console.log(pc2.yellow("  Aborted."));
+        } else if (err?.message?.includes("-32601") || err?.code === -32601) {
+          let msg = "Server does not support this feature (Method not found)";
+          if (trimmed.startsWith("prompts/")) msg = "This server does not have any prompts.";
+          else if (trimmed.startsWith("resources/"))
+            msg = "This server does not have any resources.";
+          else if (trimmed.startsWith("tools/")) msg = "This server does not have any tools.";
+          console.log(pc2.yellow(`  ${msg}`));
         } else {
-          console.error(pc.red(`\u2717 Error: ${err.message}`));
+          console.error(pc2.red(`\u2717 Error: ${err.message}`));
         }
       }
       if (activeRl) {
@@ -1431,7 +2154,7 @@ function startReadlineLoop(target, interceptor) {
     closed = true;
     activeRl = null;
     if (!globalPauseReadlineClose) {
-      console.log(pc.dim("\nShutting down..."));
+      console.log(pc2.dim("\nShutting down..."));
       await target.close();
       process.exit(0);
     }
@@ -1448,6 +2171,9 @@ async function handleCommand(input3, target, interceptor) {
     case "help":
       printHelp();
       return;
+    case "?":
+      printShortHelp();
+      return;
     case "explore":
     case "interactive":
       await withSuspendedReadline(target, interceptor, async () => {
@@ -1461,8 +2187,7 @@ async function handleCommand(input3, target, interceptor) {
       await cmdToolsDescribe(target, rest);
       return;
     case "tools/call":
-      await cmdToolsCall(target, interceptor, rest);
-      return;
+      return await cmdToolsCall(target, interceptor, rest);
     case "tools/scaffold":
       await cmdToolsScaffold(target, rest);
       return;
@@ -1473,8 +2198,7 @@ async function handleCommand(input3, target, interceptor) {
       await cmdResourcesList(target);
       return;
     case "resources/read":
-      await cmdResourcesRead(target, rest);
-      return;
+      return await cmdResourcesRead(target, rest, interceptor);
     case "resources/templates":
       await cmdResourcesTemplates(target);
       return;
@@ -1482,8 +2206,7 @@ async function handleCommand(input3, target, interceptor) {
       await cmdPromptsList(target);
       return;
     case "prompts/get":
-      await cmdPromptsGet(target, rest);
-      return;
+      return await cmdPromptsGet(target, rest, interceptor);
     case "timing":
       cmdTiming();
       return;
@@ -1520,32 +2243,38 @@ async function handleCommand(input3, target, interceptor) {
     case "!!":
     case "last":
       if (lastCommand) {
-        console.log(pc.dim(`  Re-running: ${lastCommand}`));
-        await handleCommand(lastCommand, target, interceptor);
+        console.log(pc2.dim(`  Re-running: ${lastCommand}`));
+        return await handleCommand(lastCommand, target, interceptor);
       } else {
-        console.log(pc.yellow("No previous command to re-run."));
+        console.log(pc2.yellow("No previous command to re-run."));
       }
       return;
     case "status":
       cmdStatus(target);
       return;
     case "exit":
-    case "quit":
-      process.emit("SIGINT", "SIGINT");
+    case "quit": {
+      console.log(pc2.dim("Shutting down..."));
+      await target.close();
+      process.exit(0);
       return;
+    }
     default: {
-      const suggestion = suggestCommand(cmd, KNOWN_COMMANDS);
+      if (cachedToolNames.includes(cmd)) {
+        return await cmdToolsCall(target, interceptor, input3);
+      }
+      const suggestion = suggestCommand(cmd, getActiveCommands());
       if (suggestion) {
-        console.log(pc.yellow(`Unknown command: ${cmd}.`));
+        console.log(pc2.yellow(`Unknown command: ${cmd}.`));
         try {
           await withSuspendedReadline(target, interceptor, async () => {
             const runIt = await confirm({
-              message: `Did you mean ${pc.bold(suggestion)}?`,
+              message: `Did you mean ${pc2.bold(suggestion)}?`,
               default: true
             });
             if (runIt) {
               const rebuiltCommand = rest ? `${suggestion} ${rest}` : suggestion;
-              await handleCommand(rebuiltCommand, target, interceptor);
+              return await handleCommand(rebuiltCommand, target, interceptor);
             }
           });
         } catch (err) {
@@ -1553,7 +2282,7 @@ async function handleCommand(input3, target, interceptor) {
           throw new AbortFlowError();
         }
       } else {
-        console.log(pc.yellow(`Unknown command: ${cmd}. Type ${pc.bold("help")} for usage.`));
+        console.log(pc2.yellow(`Unknown command: ${cmd}. Type ${pc2.bold("help")} for usage.`));
       }
     }
   }
@@ -1561,25 +2290,25 @@ async function handleCommand(input3, target, interceptor) {
 async function cmdToolsList(target) {
   const { tools } = await target.listTools();
   if (tools.length === 0) {
-    console.log(pc.dim("  No tools available."));
+    console.log(pc2.dim("  No tools available."));
     return;
   }
   const nameWidth = Math.max(8, ...tools.map((t) => t.name.length));
-  console.log(pc.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
-  console.log(pc.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
+  console.log(pc2.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
+  console.log(pc2.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
   for (const tool of tools) {
-    const desc = tool.description ? tool.description.length > 60 ? `${tool.description.slice(0, 57)}...` : tool.description : pc.dim("(no description)");
-    console.log(`  ${pc.green(tool.name.padEnd(nameWidth))}  ${desc}`);
+    const desc = tool.description ? tool.description.length > 60 ? `${tool.description.slice(0, 57)}...` : tool.description : pc2.dim("(no description)");
+    console.log(`  ${pc2.green(tool.name.padEnd(nameWidth))}  ${desc}`);
   }
-  console.log(pc.dim(`
+  console.log(pc2.dim(`
   ${tools.length} tool(s) total.`));
   if (tools.length >= 10) {
     const groups = groupToolsByPrefix(tools.map((t) => t.name));
     if (!groups.has("All")) {
       console.log();
-      console.log(pc.bold("  Groups:"));
+      console.log(pc2.bold("  Groups:"));
       for (const [label, members] of groups) {
-        console.log(`    ${pc.cyan(label.padEnd(16))} ${pc.dim(members.join(", "))}`);
+        console.log(`    ${pc2.cyan(label.padEnd(16))} ${pc2.dim(members.join(", "))}`);
       }
     }
   }
@@ -1587,28 +2316,28 @@ async function cmdToolsList(target) {
 async function cmdToolsDescribe(target, rest) {
   const name = rest.trim();
   if (!name) {
-    console.log(pc.yellow("  Usage: tools/describe <name>"));
+    console.log(pc2.yellow("  Usage: tools/describe <name>"));
     if (cachedToolNames.length > 0) {
       const preview = cachedToolNames.slice(0, 6);
       const more = cachedToolNames.length > 6 ? `, ... (${cachedToolNames.length} total)` : "";
-      console.log(pc.dim(`
+      console.log(pc2.dim(`
   Available tools: ${preview.join(", ")}${more}`));
-      console.log(pc.dim(`  Type ${pc.bold("tools/list")} for all.`));
+      console.log(pc2.dim(`  Type ${pc2.bold("tools/list")} for all.`));
     }
     return;
   }
   const { tools } = await target.listTools();
   const tool = tools.find((t) => t.name === name);
   if (!tool) {
-    console.log(pc.red(`Tool "${name}" not found.`));
+    console.log(pc2.red(`Tool "${name}" not found.`));
     const suggestion = suggestCommand(
       name,
       tools.map((t) => t.name)
     );
     if (suggestion) {
-      console.log(pc.yellow(`Did you mean ${pc.bold(suggestion)}?`));
+      console.log(pc2.yellow(`Did you mean ${pc2.bold(suggestion)}?`));
     } else {
-      console.log(pc.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+      console.log(pc2.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
     }
     return;
   }
@@ -1628,46 +2357,79 @@ async function cmdToolsCall(target, interceptor, rest) {
   const cleanedRest = clearPrevious ? rest.replace(/\s*--clear/, "").trim() : rest;
   const { toolName, jsonArgs, timeoutMs } = parseCallArgs(cleanedRest);
   if (!toolName) {
-    console.log(pc.yellow("  Usage: tools/call <name> [json_args] [--timeout <ms>]"));
+    if (!isScriptMode && cachedToolNames.length > 0 && process.stdin.isTTY) {
+      const picked = await withSuspendedReadline(target, interceptor, async () => {
+        const tools = await target.listTools();
+        return pickInteractive(
+          tools.tools.map((t) => ({ name: t.name, description: t.description })),
+          "Pick a tool to call:"
+        );
+      });
+      if (!picked) return;
+      return cmdToolsCall(target, interceptor, picked);
+    }
+    console.log(pc2.yellow("  Usage: tools/call <name> [json_args] [--timeout <ms>]"));
     if (cachedToolNames.length > 0) {
       const preview = cachedToolNames.slice(0, 6);
       const more = cachedToolNames.length > 6 ? `, ... (${cachedToolNames.length} total)` : "";
-      console.log(pc.dim(`
+      console.log(pc2.dim(`
   Available tools: ${preview.join(", ")}${more}`));
       console.log(
-        pc.dim(`  Run without args for ${pc.bold("interactive mode")}: tools/call <name>`)
+        pc2.dim(`  Run without args for ${pc2.bold("interactive mode")}: tools/call <name>`)
       );
     }
     return;
   }
   let args = {};
   if (jsonArgs) {
-    try {
-      args = JSON.parse(jsonArgs);
-    } catch (err) {
-      console.error(pc.red(`Invalid JSON: ${err.message}`));
-      console.log(pc.dim(`  Received: ${jsonArgs}`));
-      return;
+    const trimmed = jsonArgs.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        args = JSON.parse(trimmed);
+      } catch (err) {
+        console.error(pc2.red(`Invalid JSON: ${err.message}`));
+        console.log(pc2.dim(`  Received: ${jsonArgs}`));
+        return;
+      }
+    } else {
+      try {
+        args = parseHttpieArgs(trimmed);
+      } catch (err) {
+        console.error(pc2.red(`Invalid shorthand arguments: ${err.message}`));
+        return;
+      }
     }
     const { tools } = await target.listTools();
     const tool = tools.find((t) => t.name === toolName);
-    if (tool) {
-      const schema = tool.inputSchema;
-      const required = schema.required ?? [];
-      const missing = required.filter((r) => !(r in args));
-      if (missing.length > 0) {
-        console.log(pc.yellow(`
-  Missing required arguments: ${missing.join(", ")}`));
-        console.log();
-        const scaffolded = scaffoldArgs(schema);
-        console.log(pc.dim("  Try:"));
-        console.log(`    tools/call ${toolName} ${scaffolded}`);
-        console.log();
-        console.log(pc.dim("  Or run without args for interactive mode:"));
-        console.log(`    tools/call ${toolName}`);
-        console.log();
-        return;
+    if (!tool) {
+      console.log(pc2.red(`
+  \u2717 Tool "${toolName}" not found.`));
+      const toolNames = tools.map((t) => t.name);
+      const suggestion = suggestCommand(toolName, toolNames);
+      if (suggestion) {
+        console.log(pc2.yellow(`  \u{1F4A1} Did you mean "${suggestion}"?`));
+      } else {
+        const preview = toolNames.slice(0, 6);
+        const more = toolNames.length > 6 ? `, ... (${toolNames.length} total)` : "";
+        console.log(pc2.dim(`  Available tools: ${preview.join(", ")}${more}`));
       }
+      return { isError: true, content: [{ type: "text", text: `Tool not found: ${toolName}` }] };
+    }
+    const schema = tool.inputSchema;
+    const required = schema.required ?? [];
+    const missing = required.filter((r) => !(r in args));
+    if (missing.length > 0) {
+      console.log(pc2.yellow(`
+  Missing required arguments: ${missing.join(", ")}`));
+      console.log();
+      const scaffolded = scaffoldArgs(schema);
+      console.log(pc2.dim("  Try:"));
+      console.log(`    tools/call ${toolName} ${scaffolded}`);
+      console.log();
+      console.log(pc2.dim("  Or run without args for interactive mode:"));
+      console.log(`    tools/call ${toolName}`);
+      console.log();
+      return;
     }
   } else {
     const collectedArgs = await interactiveArgPrompt(target, interceptor, toolName, clearPrevious);
@@ -1681,56 +2443,72 @@ async function cmdToolsCall(target, interceptor, rest) {
       }
     }
   }
-  console.log(pc.dim(`  Calling ${toolName}...`));
+  console.log(pc2.dim(`  Calling ${toolName}...`));
   const startTime = Date.now();
   const result = await interceptor.callTool(target, toolName, args, timeoutMs);
   const elapsed = Date.now() - startTime;
   callHistory.push({ toolName, durationMs: elapsed, timestamp: startTime });
   lastToolArgsMap.set(toolName, { ...args });
-  const width = 60;
   const isError = result.isError === true;
-  const topText = isError ? "Error" : "Result";
-  const resultLabel = isError ? pc.red("Error") : pc.green("Result");
-  const topPads = Math.max(0, width - 4 - topText.length);
-  console.log(`
-  ${pc.dim("\u2500\u2500")} ${resultLabel} ${pc.dim("\u2500".repeat(topPads))}`);
+  console.log();
+  printResultBlock({
+    label: isError ? "Error" : "Result",
+    labelColor: isError ? "red" : "green",
+    elapsed,
+    toolName
+  });
   const content = result.content;
   if (Array.isArray(content)) {
     for (const item of content) {
       if (item.type === "text") {
-        console.log(isError ? pc.red(`  \u2717 ${item.text}`) : `  ${item.text}`);
+        if (isError) {
+          console.log(pc2.red(`  \u2717 ${item.text}`));
+        } else {
+          try {
+            const parsed = JSON.parse(item.text);
+            if (typeof parsed === "object" && parsed !== null) {
+              console.log(formatJson(parsed, 2, true));
+            } else {
+              console.log(pc2.yellow(`  ${item.text}`));
+            }
+          } catch {
+            console.log(pc2.yellow(`  ${item.text}`));
+          }
+        }
       } else {
-        console.log(formatJson(item, 2));
+        console.log(formatJson(item, 2, true));
       }
     }
   } else {
-    console.log(formatJson(result, 2));
+    console.log(formatJson(result, 2, true));
   }
   if (isError) {
-    console.log(
-      pc.yellow(
-        `  \u{1F4A1} Tip: Check the tool arguments via 'tools/describe ${toolName}' 
+    const errText = Array.isArray(content) ? content.map((c) => c.text || "").join(" ").toLowerCase() : typeof content === "object" ? (content.text || "").toLowerCase() : "";
+    if (errText.includes("argument") || errText.includes("validation") || errText.includes("schema") || errText.includes("missing") || errText.includes("invalid")) {
+      console.log(
+        pc2.yellow(
+          `  \u{1F4A1} Tip: Check the tool arguments via 'tools/describe ${toolName}' 
           or view the raw server stderr above.`
-      )
-    );
+        )
+      );
+    }
   }
-  const elapsedStr = `${elapsed}ms`;
-  const bottomPads = Math.max(0, width - 4 - elapsedStr.length);
-  console.log(`  ${pc.dim("\u2500".repeat(bottomPads))} ${pc.dim(elapsedStr)} ${pc.dim("\u2500\u2500")}`);
+  console.log();
+  return result;
 }
 async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious = false) {
   const { tools } = await target.listTools();
   const tool = tools.find((t) => t.name === toolName);
   if (!tool) {
-    console.log(pc.red(`Tool "${toolName}" not found.`));
+    console.log(pc2.red(`Tool "${toolName}" not found.`));
     const suggestion = suggestCommand(
       toolName,
       tools.map((t) => t.name)
     );
     if (suggestion) {
-      console.log(pc.yellow(`Did you mean ${pc.bold(suggestion)}?`));
+      console.log(pc2.yellow(`Did you mean ${pc2.bold(suggestion)}?`));
     } else {
-      console.log(pc.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+      console.log(pc2.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
     }
     return null;
   }
@@ -1740,9 +2518,9 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
     return {};
   }
   if (isScriptMode) {
-    console.log(pc.yellow(`  Tool "${toolName}" requires arguments.`));
+    console.log(pc2.yellow(`  Tool "${toolName}" requires arguments.`));
     const scaffolded = scaffoldArgs(schema);
-    console.log(pc.dim(`  Usage: tools/call ${toolName} ${scaffolded}`));
+    console.log(pc2.dim(`  Usage: tools/call ${toolName} ${scaffolded}`));
     return null;
   }
   const required = schema.required ?? [];
@@ -1751,10 +2529,10 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
   const optionalProps = allProps.filter(([name]) => !required.includes(name));
   const previousArgs = clearPrevious ? void 0 : lastToolArgsMap.get(toolName);
   console.log();
-  console.log(`  ${pc.bold(tool.name)}${tool.description ? pc.dim(` \u2014 ${tool.description}`) : ""}`);
+  console.log(`  ${pc2.bold(tool.name)}${tool.description ? pc2.dim(` \u2014 ${tool.description}`) : ""}`);
   if (previousArgs) {
-    console.log(pc.dim(`  Previous: ${JSON.stringify(previousArgs)}`));
-    console.log(pc.dim("  Press Enter to reuse values, or type to override."));
+    console.log(pc2.dim(`  Previous: ${JSON.stringify(previousArgs)}`));
+    console.log(pc2.dim("  Press Enter to reuse values, or type to override."));
   }
   console.log();
   const collectedArgs = {};
@@ -1772,9 +2550,21 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
         const typeStr = prop.type ?? "any";
         const desc = prop.description ?? "";
         const prevVal = previousArgs?.[name];
-        const label = desc ? `${name} ${pc.dim(`(${typeStr})`)} ${pc.dim(desc)}` : `${name} ${pc.dim(`(${typeStr})`)}`;
-        const answerStr = await input(
-          { message: label, default: prevVal !== void 0 ? String(prevVal) : void 0 },
+        const label = desc ? `${name} ${pc2.dim(`(${typeStr})`)} ${pc2.dim(desc)}` : `${name} ${pc2.dim(`(${typeStr})`)}`;
+        const answerStr = await input2(
+          {
+            message: label,
+            default: prevVal !== void 0 ? String(prevVal) : void 0,
+            validate: (val) => {
+              if (!val && typeStr !== "string") {
+                return "This argument is required and cannot be empty.";
+              }
+              if (val && (typeStr === "number" || typeStr === "integer") && Number.isNaN(Number(val))) {
+                return "Must be a valid number.";
+              }
+              return true;
+            }
+          },
           { signal: abortController.signal }
         );
         collectedArgs[name] = coerceValue(answerStr, typeStr);
@@ -1802,16 +2592,25 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
           const typeStr = prop.type ?? "any";
           const desc = prop.description ?? "";
           const prevVal = previousArgs?.[name];
-          const label = desc ? `${name} ${pc.dim(`(${typeStr})`)} ${pc.dim(desc)}` : `${name} ${pc.dim(`(${typeStr})`)}`;
-          const answerStr = await input(
-            { message: label, default: prevVal !== void 0 ? String(prevVal) : void 0 },
+          const label = desc ? `${name} ${pc2.dim(`(${typeStr})`)} ${pc2.dim(desc)}` : `${name} ${pc2.dim(`(${typeStr})`)}`;
+          const answerStr = await input2(
+            {
+              message: label,
+              default: prevVal !== void 0 ? String(prevVal) : void 0,
+              validate: (val) => {
+                if (val && (typeStr === "number" || typeStr === "integer") && Number.isNaN(Number(val))) {
+                  return "Must be a valid number.";
+                }
+                return true;
+              }
+            },
             { signal: abortController.signal }
           );
           collectedArgs[name] = coerceValue(answerStr, typeStr);
         }
       }
       console.log();
-      console.log(pc.dim(`  ${JSON.stringify(collectedArgs)}`));
+      console.log(formatJson(collectedArgs, 2, true));
       const shouldExecute = await confirm(
         { message: "Execute?", default: true },
         { signal: abortController.signal }
@@ -1832,14 +2631,14 @@ function printJsonTemplate(filled, allProps, currentProp) {
   const parts = [];
   for (const [name] of allProps) {
     if (name in filled) {
-      parts.push(`"${name}": ${pc.green(JSON.stringify(filled[name]))}`);
+      parts.push(`"${name}": ${pc2.green(JSON.stringify(filled[name]))}`);
     } else if (name === currentProp) {
-      parts.push(`"${name}": ${pc.yellow("\u2592")}`);
+      parts.push(`"${name}": ${pc2.yellow("\u2592")}`);
     } else {
-      parts.push(`"${name}": ${pc.dim("\u2592")}`);
+      parts.push(`"${name}": ${pc2.dim("\u2592")}`);
     }
   }
-  console.log(pc.dim("  { ") + parts.join(pc.dim(", ")) + pc.dim(" }"));
+  console.log(pc2.dim("  { ") + parts.join(pc2.dim(", ")) + pc2.dim(" }"));
   console.log();
 }
 function coerceValue(input3, type) {
@@ -1856,7 +2655,7 @@ function coerceValue(input3, type) {
   }
 }
 function question(rl, prompt) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let aborted = false;
     const onKeypress = (_str, key) => {
       if (key && key.name === "escape") {
@@ -1880,7 +2679,7 @@ function question(rl, prompt) {
       if (aborted) {
         reject(new AbortFlowError());
       } else {
-        resolve(answer);
+        resolve2(answer);
       }
     });
   });
@@ -1888,11 +2687,11 @@ function question(rl, prompt) {
 async function cmdToolsScaffold(target, rest) {
   const name = rest.trim();
   if (!name) {
-    console.log(pc.yellow("  Usage: tools/scaffold <name>"));
+    console.log(pc2.yellow("  Usage: tools/scaffold <name>"));
     if (cachedToolNames.length > 0) {
       const preview = cachedToolNames.slice(0, 6);
       const more = cachedToolNames.length > 6 ? `, ... (${cachedToolNames.length} total)` : "";
-      console.log(pc.dim(`
+      console.log(pc2.dim(`
   Available tools: ${preview.join(", ")}${more}`));
     }
     return;
@@ -1900,158 +2699,247 @@ async function cmdToolsScaffold(target, rest) {
   const { tools } = await target.listTools();
   const tool = tools.find((t) => t.name === name);
   if (!tool) {
-    console.log(pc.red(`Tool "${name}" not found.`));
+    console.log(pc2.red(`Tool "${name}" not found.`));
     const suggestion = suggestCommand(
       name,
       tools.map((t) => t.name)
     );
     if (suggestion) {
-      console.log(pc.yellow(`Did you mean ${pc.bold(suggestion)}?`));
+      console.log(pc2.yellow(`Did you mean ${pc2.bold(suggestion)}?`));
     } else {
-      console.log(pc.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+      console.log(pc2.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
     }
     return;
   }
   const scaffolded = scaffoldArgs(tool.inputSchema);
-  console.log(pc.cyan("\n  Ready-to-paste command:"));
+  console.log(pc2.cyan("\n  Ready-to-paste command:"));
   console.log(`  tools/call ${name} ${scaffolded}
 `);
 }
 async function cmdResourcesList(target) {
   const { resources } = await target.listResources();
   if (resources.length === 0) {
-    console.log(pc.dim("  No resources available."));
+    console.log(pc2.dim("  No resources available."));
     return;
   }
   const uriWidth = Math.max(6, ...resources.map((r) => r.uri.length));
-  console.log(pc.bold(`  ${"URI".padEnd(uriWidth)}  Name`));
-  console.log(pc.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
+  console.log(pc2.bold(`  ${"URI".padEnd(uriWidth)}  Name`));
+  console.log(pc2.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
   for (const r of resources) {
     const uri = r.uri;
-    const name = r.name ?? pc.dim("(unnamed)");
-    console.log(`  ${pc.green(uri.padEnd(uriWidth))}  ${name}`);
+    const name = r.name ?? pc2.dim("(unnamed)");
+    console.log(`  ${pc2.green(uri.padEnd(uriWidth))}  ${name}`);
   }
-  console.log(pc.dim(`
+  console.log(pc2.dim(`
   ${resources.length} resource(s) total.`));
 }
-async function cmdResourcesRead(target, rest) {
+async function cmdResourcesRead(target, rest, interceptor) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc.yellow("  Usage: resources/read <uri>"));
+    if (!isScriptMode && cachedResourceUris.length > 0 && process.stdin.isTTY && interceptor) {
+      const picked = await withSuspendedReadline(target, interceptor, async () => {
+        const { resources } = await target.listResources();
+        return pickInteractive(
+          resources.map((r) => ({
+            name: r.uri,
+            description: r.description || r.name
+          })),
+          "Pick a resource to read:"
+        );
+      });
+      if (!picked) return;
+      return cmdResourcesRead(target, picked, interceptor);
+    }
+    console.log(pc2.yellow("  Usage: resources/read <uri>"));
     if (cachedResourceUris.length > 0) {
       const preview = cachedResourceUris.slice(0, 5);
       const more = cachedResourceUris.length > 5 ? `, ... (${cachedResourceUris.length} total)` : "";
-      console.log(pc.dim(`
+      console.log(pc2.dim(`
   Available resources: ${preview.join(", ")}${more}`));
     }
     return;
   }
+  const startTime = Date.now();
   const result = await target.readResource({ uri });
+  const elapsed = Date.now() - startTime;
+  console.log();
+  printResultBlock({ label: "Resource", labelColor: "cyan", elapsed, detail: uri });
   for (const item of result.contents) {
     if (item.text !== void 0) {
-      console.log(item.text);
+      const text = item.text;
+      try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "object" && parsed !== null) {
+          console.log(formatJson(parsed, 2, true));
+        } else {
+          console.log(pc2.yellow(`  ${text}`));
+        }
+      } catch {
+        console.log(pc2.yellow(`  ${text}`));
+      }
     } else if (item.blob !== void 0) {
       const mimeType = item.mimeType ?? "application/octet-stream";
       const sizeBytes = Buffer.from(item.blob, "base64").length;
-      console.log(pc.dim(`[Binary: ${mimeType}, ${sizeBytes} bytes]`));
+      console.log(pc2.dim(`  [Binary: ${mimeType}, ${sizeBytes} bytes]`));
     } else {
-      console.log(formatJson(item, 2));
+      console.log(formatJson(item, 2, true));
     }
   }
+  console.log();
+  return result;
 }
 async function cmdResourcesTemplates(target) {
   const { resourceTemplates } = await target.listResourceTemplates();
   if (resourceTemplates.length === 0) {
-    console.log(pc.dim("  No resource templates available."));
+    console.log(pc2.dim("  No resource templates available."));
     return;
   }
   const uriWidth = Math.max(
     12,
     ...resourceTemplates.map((t) => t.uriTemplate.length)
   );
-  console.log(pc.bold(`  ${"URI Template".padEnd(uriWidth)}  Name`));
-  console.log(pc.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
+  console.log(pc2.bold(`  ${"URI Template".padEnd(uriWidth)}  Name`));
+  console.log(pc2.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
   for (const t of resourceTemplates) {
     const uriTemplate = t.uriTemplate;
-    const name = t.name ?? pc.dim("(unnamed)");
-    console.log(`  ${pc.green(uriTemplate.padEnd(uriWidth))}  ${name}`);
+    const name = t.name ?? pc2.dim("(unnamed)");
+    console.log(`  ${pc2.green(uriTemplate.padEnd(uriWidth))}  ${name}`);
   }
-  console.log(pc.dim(`
+  console.log(pc2.dim(`
   ${resourceTemplates.length} template(s) total.`));
 }
 async function cmdPromptsList(target) {
   const { prompts } = await target.listPrompts();
   if (prompts.length === 0) {
-    console.log(pc.dim("  No prompts available."));
+    console.log(pc2.dim("  No prompts available."));
     return;
   }
   const nameWidth = Math.max(8, ...prompts.map((p) => p.name.length));
-  console.log(pc.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
-  console.log(pc.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
+  console.log(pc2.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
+  console.log(pc2.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
   for (const p of prompts) {
-    const desc = p.description ? p.description.length > 60 ? `${p.description.slice(0, 57)}...` : p.description : pc.dim("(no description)");
-    console.log(`  ${pc.green(p.name.padEnd(nameWidth))}  ${desc}`);
+    const desc = p.description ? p.description.length > 60 ? `${p.description.slice(0, 57)}...` : p.description : pc2.dim("(no description)");
+    console.log(`  ${pc2.green(p.name.padEnd(nameWidth))}  ${desc}`);
   }
-  console.log(pc.dim(`
+  console.log(pc2.dim(`
   ${prompts.length} prompt(s) total.`));
 }
-async function cmdPromptsGet(target, rest) {
+async function cmdPromptsGet(target, rest, interceptor) {
   const { toolName: promptName, jsonArgs } = parseCallArgs(rest);
   if (!promptName) {
-    console.log(pc.yellow("  Usage: prompts/get <name> [json_args]"));
+    if (!isScriptMode && cachedPromptNames.length > 0 && process.stdin.isTTY && interceptor) {
+      const picked = await withSuspendedReadline(target, interceptor, async () => {
+        const { prompts: prompts2 } = await target.listPrompts();
+        return pickInteractive(
+          prompts2.map((p) => ({ name: p.name, description: p.description })),
+          "Pick a prompt to get:"
+        );
+      });
+      if (!picked) return;
+      return cmdPromptsGet(target, picked);
+    }
+    console.log(pc2.yellow("  Usage: prompts/get <name> [json_args]"));
     if (cachedPromptNames.length > 0) {
-      console.log(pc.dim(`
+      console.log(pc2.dim(`
   Available prompts: ${cachedPromptNames.join(", ")}`));
     }
     return;
   }
   let promptArgs = {};
   if (jsonArgs) {
-    try {
-      promptArgs = JSON.parse(jsonArgs);
-    } catch (err) {
-      console.error(pc.red(`Invalid JSON: ${err.message}`));
-      console.log(pc.dim(`  Received: ${jsonArgs}`));
-      return;
+    const trimmed = jsonArgs.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        promptArgs = JSON.parse(trimmed);
+      } catch (err) {
+        console.error(pc2.red(`Invalid JSON: ${err.message}`));
+        console.log(pc2.dim(`  Received: ${jsonArgs}`));
+        return;
+      }
+    } else {
+      try {
+        promptArgs = parseHttpieArgs(trimmed);
+      } catch (err) {
+        console.error(pc2.red(`Invalid shorthand arguments: ${err.message}`));
+        return;
+      }
+    }
+  }
+  const { prompts } = await target.listPrompts();
+  const prompt = prompts.find((p) => p.name === promptName);
+  if (!prompt) {
+    console.log(pc2.red(`
+  \u2717 Prompt "${promptName}" not found.`));
+    const promptNames = prompts.map((p) => p.name);
+    const suggestion = suggestCommand(promptName, promptNames);
+    if (suggestion) {
+      console.log(pc2.yellow(`  \u{1F4A1} Did you mean "${suggestion}"?`));
+    } else {
+      console.log(pc2.dim(`  Available prompts: ${promptNames.join(", ")}`));
     }
+    return { isError: true, content: [{ type: "text", text: `Prompt not found: ${promptName}` }] };
   }
+  const startTime = Date.now();
   const result = await target.getPrompt({ name: promptName, arguments: promptArgs });
+  const elapsed = Date.now() - startTime;
+  if (result.messages.length === 0) {
+    console.log(pc2.dim("  No messages returned."));
+    return;
+  }
+  console.log();
+  printResultBlock({ label: "Prompt", labelColor: "blue", elapsed, detail: promptName });
   for (const msg of result.messages) {
-    const role = msg.role === "user" ? pc.blue("user") : pc.magenta("assistant");
+    const role = msg.role === "user" ? pc2.blue("user") : pc2.magenta("assistant");
     const text = msg.content.text ?? JSON.stringify(msg.content);
-    console.log(`  ${pc.bold(role)}: ${text}`);
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed === "object" && parsed !== null) {
+        console.log(`  ${pc2.bold(role)}:`);
+        console.log(formatJson(parsed, 4, true));
+      } else {
+        console.log(`  ${pc2.bold(role)}: ${pc2.yellow(text)}`);
+      }
+    } catch {
+      console.log(`  ${pc2.bold(role)}: ${pc2.yellow(text)}`);
+    }
   }
+  console.log();
+  return result;
 }
 async function cmdPing(target) {
   try {
     const elapsed = await target.ping();
-    console.log(pc.green(`  \u2713 Pong! Round-trip: ${elapsed}ms`));
+    console.log();
+    console.log(pc2.green(`  \u2713 Pong! Round-trip: ${elapsed}ms`));
+    console.log();
   } catch (err) {
-    console.error(pc.red(`  \u2717 Ping failed: ${err.message}`));
+    console.log();
+    console.error(pc2.red(`  \u2717 Ping failed: ${err.message}`));
+    console.log();
   }
 }
 async function cmdLogLevel(target, rest) {
   const level = rest.trim().toLowerCase();
   if (!level) {
-    console.log(pc.yellow("  Usage: log-level <level>"));
-    console.log(pc.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
+    console.log(pc2.yellow("  Usage: log-level <level>"));
+    console.log(pc2.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
     return;
   }
   if (!LOG_LEVELS.includes(level)) {
     const suggestion = suggestCommand(level, [...LOG_LEVELS]);
     const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
-    console.log(pc.red(`  Unknown log level: "${level}".${hint}`));
-    console.log(pc.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
+    console.log(pc2.red(`  Unknown log level: "${level}".${hint}`));
+    console.log(pc2.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
     return;
   }
   try {
     await target.setLoggingLevel(level);
-    console.log(pc.green(`  \u2713 Logging level set to: ${level}`));
+    console.log(pc2.green(`  \u2713 Logging level set to: ${level}`));
   } catch (err) {
-    console.error(pc.red(`  \u2717 Failed to set log level: ${err.message}`));
+    console.error(pc2.red(`  \u2717 Failed to set log level: ${err.message}`));
     const caps = target.getServerCapabilities();
     if (!caps?.logging) {
-      console.log(pc.dim("  The server does not advertise logging support."));
+      console.log(pc2.dim("  The server does not advertise logging support."));
     }
   }
 }
@@ -2059,28 +2947,28 @@ function cmdHistory(target, rest) {
   const arg = rest.trim();
   if (arg === "clear") {
     target.clearHistory();
-    console.log(pc.dim("  History cleared."));
+    console.log(pc2.dim("  History cleared."));
     return;
   }
   const count = arg ? Number.parseInt(arg, 10) : 20;
   const records = target.getHistory(Number.isNaN(count) ? 20 : count);
   if (records.length === 0) {
-    console.log(pc.dim("  No request history yet."));
+    console.log(pc2.dim("  No request history yet."));
     return;
   }
-  console.log(pc.bold("\n  Request History"));
-  console.log(pc.dim(`  ${"\u2500".repeat(70)}`));
+  console.log(pc2.bold("\n  Request History"));
+  console.log(pc2.dim(`  ${"\u2500".repeat(70)}`));
   for (const rec of records) {
     const time = new Date(rec.timestamp).toLocaleTimeString();
     const dur = `${rec.durationMs}ms`;
-    const hasError = rec.error ? pc.red(" \u2717") : "";
+    const hasError = rec.error ? pc2.red(" \u2717") : "";
     console.log(
-      `  ${pc.dim(`#${rec.id}`)} ${pc.dim(time)} ${pc.green(rec.method.padEnd(30))} ${pc.cyan(dur.padStart(8))}${hasError}`
+      `  ${pc2.dim(`#${rec.id}`)} ${pc2.dim(time)} ${pc2.green(rec.method.padEnd(30))} ${pc2.cyan(dur.padStart(8))}${hasError}`
     );
   }
   const total = target.getHistory().length;
   console.log(
-    pc.dim(`
+    pc2.dim(`
   Showing ${records.length} of ${total} total. Use "history clear" to reset.`)
   );
   console.log();
@@ -2089,26 +2977,26 @@ function cmdNotifications(target, rest) {
   const arg = rest.trim();
   if (arg === "clear") {
     target.clearNotifications();
-    console.log(pc.dim("  Notifications cleared."));
+    console.log(pc2.dim("  Notifications cleared."));
     return;
   }
   const count = arg ? Number.parseInt(arg, 10) : 20;
   const records = target.getNotifications(Number.isNaN(count) ? 20 : count);
   if (records.length === 0) {
-    console.log(pc.dim("  No notifications received yet."));
-    console.log(pc.dim("  Notifications appear inline as they arrive from the server."));
+    console.log(pc2.dim("  No notifications received yet."));
+    console.log(pc2.dim("  Notifications appear inline as they arrive from the server."));
     return;
   }
-  console.log(pc.bold("\n  Server Notifications"));
-  console.log(pc.dim(`  ${"\u2500".repeat(70)}`));
+  console.log(pc2.bold("\n  Server Notifications"));
+  console.log(pc2.dim(`  ${"\u2500".repeat(70)}`));
   for (const n of records) {
     const time = new Date(n.timestamp).toLocaleTimeString();
-    const params = n.params ? ` ${pc.dim(JSON.stringify(n.params))}` : "";
-    console.log(`  ${pc.dim(time)} ${pc.yellow(n.method)}${params}`);
+    const params = n.params ? ` ${pc2.dim(JSON.stringify(n.params))}` : "";
+    console.log(`  ${pc2.dim(time)} ${pc2.yellow(n.method)}${params}`);
   }
   const total = target.getNotifications().length;
   console.log(
-    pc.dim(`
+    pc2.dim(`
   Showing ${records.length} of ${total} total. Use "notifications clear" to reset.`)
   );
   console.log();
@@ -2116,44 +3004,44 @@ function cmdNotifications(target, rest) {
 async function cmdResourcesSubscribe(target, rest) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc.yellow("  Usage: resources/subscribe <uri>"));
+    console.log(pc2.yellow("  Usage: resources/subscribe <uri>"));
     if (cachedResourceUris.length > 0) {
-      console.log(pc.dim(`  Available: ${cachedResourceUris.join(", ")}`));
+      console.log(pc2.dim(`  Available: ${cachedResourceUris.join(", ")}`));
     }
     return;
   }
   try {
     await target.subscribeResource({ uri });
-    console.log(pc.green(`  \u2713 Subscribed to: ${uri}`));
-    console.log(pc.dim("  You'll see notifications when this resource changes."));
+    console.log(pc2.green(`  \u2713 Subscribed to: ${uri}`));
+    console.log(pc2.dim("  You'll see notifications when this resource changes."));
   } catch (err) {
-    console.error(pc.red(`  \u2717 Subscribe failed: ${err.message}`));
+    console.error(pc2.red(`  \u2717 Subscribe failed: ${err.message}`));
   }
 }
 async function cmdResourcesUnsubscribe(target, rest) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc.yellow("  Usage: resources/unsubscribe <uri>"));
+    console.log(pc2.yellow("  Usage: resources/unsubscribe <uri>"));
     return;
   }
   try {
     await target.unsubscribeResource({ uri });
-    console.log(pc.green(`  \u2713 Unsubscribed from: ${uri}`));
+    console.log(pc2.green(`  \u2713 Unsubscribed from: ${uri}`));
   } catch (err) {
-    console.error(pc.red(`  \u2717 Unsubscribe failed: ${err.message}`));
+    console.error(pc2.red(`  \u2717 Unsubscribe failed: ${err.message}`));
   }
 }
 function cmdRootsList(target) {
   const roots = target.getRoots();
   if (roots.length === 0) {
-    console.log(pc.dim("  No roots configured."));
-    console.log(pc.dim("  Use roots/add <uri> [name] to add one."));
+    console.log(pc2.dim("  No roots configured."));
+    console.log(pc2.dim("  Use roots/add <uri> [name] to add one."));
     return;
   }
-  console.log(pc.bold("\n  Client Roots"));
+  console.log(pc2.bold("\n  Client Roots"));
   for (const r of roots) {
     const name = r.name ? ` (${r.name})` : "";
-    console.log(`  ${pc.green(r.uri)}${pc.dim(name)}`);
+    console.log(`  ${pc2.green(r.uri)}${pc2.dim(name)}`);
   }
   console.log();
 }
@@ -2162,53 +3050,53 @@ async function cmdRootsAdd(target, rest) {
   const uri = parts[0];
   const name = parts.slice(1).join(" ") || void 0;
   if (!uri) {
-    console.log(pc.yellow("  Usage: roots/add <uri> [name]"));
-    console.log(pc.dim('  Example: roots/add file:///Users/me/project "My Project"'));
+    console.log(pc2.yellow("  Usage: roots/add <uri> [name]"));
+    console.log(pc2.dim('  Example: roots/add file:///Users/me/project "My Project"'));
     return;
   }
   await target.addRoot({ uri, name });
-  console.log(pc.green(`  \u2713 Root added: ${uri}`));
-  console.log(pc.dim("  Server has been notified of the change."));
+  console.log(pc2.green(`  \u2713 Root added: ${uri}`));
+  console.log(pc2.dim("  Server has been notified of the change."));
 }
 async function cmdRootsRemove(target, rest) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc.yellow("  Usage: roots/remove <uri>"));
+    console.log(pc2.yellow("  Usage: roots/remove <uri>"));
     const roots = target.getRoots();
     if (roots.length > 0) {
-      console.log(pc.dim(`  Current roots: ${roots.map((r) => r.uri).join(", ")}`));
+      console.log(pc2.dim(`  Current roots: ${roots.map((r) => r.uri).join(", ")}`));
     }
     return;
   }
   const removed = await target.removeRoot(uri);
   if (removed) {
-    console.log(pc.green(`  \u2713 Root removed: ${uri}`));
+    console.log(pc2.green(`  \u2713 Root removed: ${uri}`));
   } else {
-    console.log(pc.yellow(`  Root not found: ${uri}`));
+    console.log(pc2.yellow(`  Root not found: ${uri}`));
   }
 }
 async function cmdReconnect(target) {
-  console.log(pc.cyan("\u27F3 Disconnecting..."));
+  console.log(pc2.cyan("\u27F3 Disconnecting..."));
   await target.close();
-  await new Promise((resolve) => setTimeout(resolve, 200));
-  console.log(pc.cyan("\u27F3 Reconnecting..."));
+  await new Promise((resolve2) => setTimeout(resolve2, 200));
+  console.log(pc2.cyan("\u27F3 Reconnecting..."));
   const { command, args } = target.getStatus();
-  console.log(pc.dim(`  Command: ${command} ${args.join(" ")}`));
+  console.log(pc2.dim(`  Command: ${command} ${args.join(" ")}`));
   try {
     await target.connect();
     const s = target.getStatus();
-    console.log(pc.green(`\u2713 Reconnected (PID: ${s.pid})`));
+    console.log(pc2.green(`\u2713 Reconnected (PID: ${s.pid})`));
     const { tools } = await target.listTools();
-    console.log(pc.cyan(`  ${tools.length} tool(s) available.
+    console.log(pc2.cyan(`  ${tools.length} tool(s) available.
 `));
     await refreshCaches(target);
   } catch (err) {
-    console.error(pc.red(`\u2717 Failed to reconnect: ${err.message}`));
+    console.error(pc2.red(`\u2717 Failed to reconnect: ${err.message}`));
   }
 }
 function cmdTiming() {
   if (callHistory.length === 0) {
-    console.log(pc.dim("  No tool calls recorded yet."));
+    console.log(pc2.dim("  No tool calls recorded yet."));
     return;
   }
   const groups = /* @__PURE__ */ new Map();
@@ -2218,8 +3106,8 @@ function cmdTiming() {
     groups.set(record.toolName, list);
   }
   const nameWidth = Math.max(8, ...[...groups.keys()].map((n) => n.length));
-  console.log(pc.bold("\n  Tool Call Performance"));
-  console.log(pc.dim(`  ${"\u2500".repeat(nameWidth + 50)}`));
+  console.log(pc2.bold("\n  Tool Call Performance"));
+  console.log(pc2.dim(`  ${"\u2500".repeat(nameWidth + 50)}`));
   let totalCalls = 0;
   let totalMs = 0;
   let slowestName = "";
@@ -2237,12 +3125,12 @@ function cmdTiming() {
       slowestName = name;
     }
     console.log(
-      `  ${pc.green(name.padEnd(nameWidth))}  \xD7 ${count}  avg: ${avg}ms    p95: ${p95}ms    max: ${max}ms`
+      `  ${pc2.green(name.padEnd(nameWidth))}  \xD7 ${count}  avg: ${avg}ms    p95: ${p95}ms    max: ${max}ms`
     );
   }
   const overallAvg = Math.round(totalMs / totalCalls);
   console.log(
-    pc.dim(
+    pc2.dim(
       `
   Total: ${totalCalls} call(s), avg ${overallAvg}ms, slowest: ${slowestName} (${slowestMs}ms)`
     )
@@ -2253,79 +3141,122 @@ function cmdStatus(target) {
   const s = target.getStatus();
   const uptimeStr = s.uptime >= 60 ? `${Math.floor(s.uptime / 60)}m ${(s.uptime % 60).toFixed(0)}s` : `${s.uptime.toFixed(1)}s`;
   const lastRespStr = s.lastResponseTime ? `${((Date.now() - s.lastResponseTime) / 1e3).toFixed(1)}s ago` : "never";
-  console.log(pc.bold("\n  Target Server Status"));
-  console.log(`  ${pc.dim("Connected:")}      ${s.connected ? pc.green("yes") : pc.red("no")}`);
-  console.log(`  ${pc.dim("PID:")}            ${s.pid ?? "N/A"}`);
-  console.log(`  ${pc.dim("Uptime:")}         ${uptimeStr}`);
-  console.log(`  ${pc.dim("Last response:")}  ${lastRespStr}`);
-  console.log(`  ${pc.dim("Stderr lines:")}   ${s.stderrLineCount.toLocaleString()}`);
-  console.log(`  ${pc.dim("Reconnects:")}     ${s.reconnectAttempts}/${s.maxReconnectAttempts}`);
-  console.log(`  ${pc.dim("Command:")}        ${s.command} ${s.args.join(" ")}`);
+  console.log(pc2.bold("\n  Target Server Status"));
+  console.log(`  ${pc2.dim("Connected:")}      ${s.connected ? pc2.green("yes") : pc2.red("no")}`);
+  console.log(`  ${pc2.dim("PID:")}            ${s.pid ?? "N/A"}`);
+  console.log(`  ${pc2.dim("Uptime:")}         ${uptimeStr}`);
+  console.log(`  ${pc2.dim("Last response:")}  ${lastRespStr}`);
+  console.log(`  ${pc2.dim("Stderr lines:")}   ${s.stderrLineCount.toLocaleString()}`);
+  console.log(`  ${pc2.dim("Reconnects:")}     ${s.reconnectAttempts}/${s.maxReconnectAttempts}`);
+  console.log(`  ${pc2.dim("Command:")}        ${s.command} ${s.args.join(" ")}`);
   console.log();
 }
+function printResultBlock(opts) {
+  const colorFn = pc2[opts.labelColor];
+  const elapsedStr = opts.elapsed < 1e3 ? `${opts.elapsed}ms` : `${(opts.elapsed / 1e3).toFixed(1)}s`;
+  const detail = opts.detail ?? opts.toolName ?? "";
+  console.log(`  ${colorFn(opts.label)}  ${pc2.dim(detail)}  ${pc2.dim(`(${elapsedStr})`)}`);
+  console.log(pc2.dim(`  ${"\u2500".repeat(60)}`));
+}
+function printShortHelp() {
+  const hasTools = !!activeCapabilities?.tools;
+  const hasResources = !!activeCapabilities?.resources;
+  const hasPrompts = !!activeCapabilities?.prompts;
+  const tC = hasTools ? pc2.green : pc2.dim;
+  const rC = hasResources ? pc2.green : pc2.dim;
+  const pC = hasPrompts ? pc2.green : pc2.dim;
+  console.log(`
+${pc2.bold("Quick Reference:")}
+
+  ${tC("tl")}  ${tC("tools/list")}        ${rC("rl")}  ${rC("resources/list")}     ${pC("pl")}  ${pC("prompts/list")}
+  ${tC("td")}  ${tC("tools/describe")}    ${rC("rr")}  ${rC("resources/read")}     ${pC("pg")}  ${pC("prompts/get")}
+  ${tC("tc")}  ${tC("tools/call")}        ${rC("rt")}  ${rC("resources/templates")}
+  ${tC("ts")}  ${tC("tools/scaffold")}    ${rC("rs")}  ${rC("resources/subscribe")}
+                          ${rC("ru")}  ${rC("resources/unsubscribe")}
+
+  ${pc2.green("ping")}  ${pc2.green("status")}  ${pc2.green("timing")}  ${pc2.green("history")}  ${pc2.green("!!")}  ${pc2.green("explore")}  ${pc2.green("reconnect")}
+
+${pc2.dim("Type 'help' for full command reference.")}
+`);
+}
 function printHelp() {
+  const hasTools = !!activeCapabilities?.tools;
+  const hasResources = !!activeCapabilities?.resources;
+  const hasPrompts = !!activeCapabilities?.prompts;
+  const hasLogging = !!activeCapabilities?.logging;
+  const tC = hasTools ? pc2.green : pc2.dim;
+  const rC = hasResources ? pc2.green : pc2.dim;
+  const pC = hasPrompts ? pc2.green : pc2.dim;
+  const lC = hasLogging ? pc2.green : pc2.dim;
+  const tD = hasTools ? (s) => s : pc2.dim;
+  const rD = hasResources ? (s) => s : pc2.dim;
+  const pD = hasPrompts ? (s) => s : pc2.dim;
+  const lD = hasLogging ? (s) => s : pc2.dim;
+  const tH = hasTools ? pc2.bold("Tool Commands:") : pc2.dim(pc2.bold("Tool Commands:")) + pc2.dim("  (Unsupported)");
+  const rH = hasResources ? pc2.bold("Resource Commands:") : pc2.dim(pc2.bold("Resource Commands:")) + pc2.dim("  (Unsupported)");
+  const pH = hasPrompts ? pc2.bold("Prompt Commands:") : pc2.dim(pc2.bold("Prompt Commands:")) + pc2.dim("  (Unsupported)");
   console.log(`
-${pc.bold("Tool Commands:")}
+${tH}
 
-  ${pc.green("tools/list")}                         List all available tools
-  ${pc.green("tools/describe")} <name>              Show a tool's input schema
-  ${pc.green("tools/call")} <name> [json] [opts]    Call a tool (interactive if no json)
-    Options: ${pc.dim("--timeout <ms>")}            Override default timeout (60s)
-             ${pc.dim("--clear")}                  Ignore remembered argument defaults
-  ${pc.green("tools/scaffold")} <name>              Generate a template for a tool's arguments
-  ${pc.green("tools/forget")} [name]                Clear remembered interactive defaults
+  ${tC("tools/list")}                         ${tD("List all available tools")}
+  ${tC("tools/describe")} <name>              ${tD("Show a tool's input schema")}
+  ${tC("tools/call")} <name> [json] [opts]    ${tD("Call a tool (interactive if no json)")}
+    ${tD("Options:")} ${pc2.dim("--timeout <ms>")}            ${tD("Override default timeout (60s)")}
+             ${pc2.dim("--clear")}                  ${tD("Ignore remembered argument defaults")}
+  ${tC("tools/scaffold")} <name>              ${tD("Generate a template for a tool's arguments")}
+  ${tC("tools/forget")} [name]                ${tD("Clear remembered interactive defaults")}
 
-${pc.bold("Resource Commands:")}
+${rH}
 
-  ${pc.green("resources/list")}                     List all available resources
-  ${pc.green("resources/read")} <uri>               Read a resource by URI
-  ${pc.green("resources/templates")}                List resource templates
-  ${pc.green("resources/subscribe")} <uri>          Subscribe to resource changes
-  ${pc.green("resources/unsubscribe")} <uri>        Unsubscribe from resource changes
+  ${rC("resources/list")}                     ${rD("List all available resources")}
+  ${rC("resources/read")} <uri>               ${rD("Read a resource by URI")}
+  ${rC("resources/templates")}                ${rD("List resource templates")}
+  ${rC("resources/subscribe")} <uri>          ${rD("Subscribe to resource changes")}
+  ${rC("resources/unsubscribe")} <uri>        ${rD("Unsubscribe from resource changes")}
 
-${pc.bold("Prompt Commands:")}
+${pH}
 
-  ${pc.green("prompts/list")}                       List all available prompts
-  ${pc.green("prompts/get")} <name> [json_args]    Get a prompt with arguments
+  ${pC("prompts/list")}                       ${pD("List all available prompts")}
+  ${pC("prompts/get")} <name> [json_args]    ${pD("Get a prompt with arguments")}
 
-${pc.bold("Protocol Commands:")}
+${pc2.bold("Protocol Commands:")}
 
-  ${pc.green("ping")}                               Verify connection, show round-trip time
-  ${pc.green("log-level")} <level>                  Set server logging verbosity
-  ${pc.green("history")} [count|clear]              Show request/response history
-  ${pc.green("notifications")} [count|clear]        Show server notifications
+  ${pc2.green("ping")}                               Verify connection, show round-trip time
+  ${lC("log-level")} <level>                  ${lD("Set server logging verbosity")}${hasLogging ? "" : pc2.dim("  (Unsupported)")}
+  ${pc2.green("history")} [count|clear]              Show request/response history
+  ${pc2.green("notifications")} [count|clear]        Show server notifications
 
-${pc.bold("Roots Management:")}
+${pc2.bold("Roots Management:")}
 
-  ${pc.green("roots/list")}                         Show configured client roots
-  ${pc.green("roots/add")} <uri> [name]             Add a root directory
-  ${pc.green("roots/remove")} <uri>                 Remove a root directory
+  ${pc2.green("roots/list")}                         Show configured client roots
+  ${pc2.green("roots/add")} <uri> [name]             Add a root directory
+  ${pc2.green("roots/remove")} <uri>                 Remove a root directory
 
-${pc.bold("Session Commands:")}
+${pc2.bold("Session Commands:")}
 
-  ${pc.green("!!")} / ${pc.green("last")}                           Re-run the last command
-  ${pc.green("reconnect")}                          Disconnect and reconnect to the server
-  ${pc.green("timing")}                             Show tool call performance stats
-  ${pc.green("status")}                             Show target server status
-  ${pc.green("help")}                               Show this help
-  ${pc.green("exit")} / ${pc.green("quit")}                         Disconnect and exit
+  ${pc2.green("!!")} / ${pc2.green("last")}                           Re-run the last command
+  ${pc2.green("reconnect")}                          Disconnect and reconnect to the server
+  ${pc2.green("timing")}                             Show tool call performance stats
+  ${pc2.green("status")}                             Show target server status
+  ${pc2.green("help")}                               Show this help
+  ${pc2.green("exit")} / ${pc2.green("quit")}                         Disconnect and exit
 
-${pc.bold("Shortcuts:")}
+${pc2.bold("Shortcuts:")}
 
-  ${pc.green("tl")}  tools/list          ${pc.green("rl")}  resources/list     ${pc.green("pl")}  prompts/list
-  ${pc.green("td")}  tools/describe      ${pc.green("rr")}  resources/read     ${pc.green("pg")}  prompts/get
-  ${pc.green("tc")}  tools/call          ${pc.green("rt")}  resources/templates
-  ${pc.green("ts")}  tools/scaffold      ${pc.green("rs")}  resources/subscribe
-                          ${pc.green("ru")}  resources/unsubscribe
+  ${tC("tl")}  ${tC("tools/list")}          ${rC("rl")}  ${rC("resources/list")}     ${pC("pl")}  ${pC("prompts/list")}
+  ${tC("td")}  ${tC("tools/describe")}      ${rC("rr")}  ${rC("resources/read")}     ${pC("pg")}  ${pC("prompts/get")}
+  ${tC("tc")}  ${tC("tools/call")}          ${rC("rt")}  ${rC("resources/templates")}
+  ${tC("ts")}  ${tC("tools/scaffold")}      ${rC("rs")}  ${rC("resources/subscribe")}
+                          ${rC("ru")}  ${rC("resources/unsubscribe")}
 
-${pc.dim("Lines starting with # are treated as comments.")}
-${pc.dim('JSON arguments can contain spaces: tools/call say {"message": "hello world"}')}
-${pc.dim("Run tools/call <name> without JSON for interactive argument prompting.")}
-${pc.dim("Use tools/call <name> --clear to ignore remembered defaults.")}
+${pc2.dim("Lines starting with # are treated as comments.")}
+${pc2.dim('JSON arguments can contain spaces: tools/call say {"message": "hello world"}')}
+${pc2.dim("Run tools/call <name> without JSON for interactive argument prompting.")}
+${pc2.dim("Use tools/call <name> --clear to ignore remembered defaults.")}
 `);
 }
 async function readScriptLines(filepath) {
-  const content = await readFile(filepath, "utf-8");
+  const content = await readFile2(filepath, "utf-8");
   return content.split("\n");
 }
 function cmdToolsForget(rest) {
@@ -2333,14 +3264,39 @@ function cmdToolsForget(rest) {
   if (toolName) {
     if (lastToolArgsMap.has(toolName)) {
       lastToolArgsMap.delete(toolName);
-      console.log(pc.green(`  Cleared remembered args for ${pc.bold(toolName)}.`));
+      console.log(pc2.green(`  Cleared remembered args for ${pc2.bold(toolName)}.`));
     } else {
-      console.log(pc.yellow(`  No remembered args for "${toolName}".`));
+      console.log(pc2.yellow(`  No remembered args for "${toolName}".`));
     }
   } else {
     const count = lastToolArgsMap.size;
     lastToolArgsMap.clear();
-    console.log(pc.green(`  Cleared remembered args for ${count} tool${count === 1 ? "" : "s"}.`));
+    console.log(pc2.green(`  Cleared remembered args for ${count} tool${count === 1 ? "" : "s"}.`));
+  }
+}
+async function pickInteractive(items, message) {
+  if (items.length === 0) return null;
+  if (!process.stdin.isTTY) return null;
+  const choices = items.map((item) => ({
+    name: item.name,
+    value: item.name,
+    description: item.description || ""
+  }));
+  try {
+    const picked = await search({
+      message,
+      source: async (term) => {
+        if (!term) return choices;
+        const lower = term.toLowerCase();
+        return choices.filter(
+          (c) => c.name.toLowerCase().includes(lower) || c.description.toLowerCase().includes(lower)
+        );
+      }
+    });
+    return picked;
+  } catch (err) {
+    if (isAbortError(err)) return null;
+    throw err;
   }
 }
 async function cmdExplore(target, interceptor) {
@@ -2384,19 +3340,19 @@ async function cmdExplore(target, interceptor) {
     }
   }
   if (choices.length === 0) {
-    console.log(pc.yellow("No tools, resources, or prompts found."));
+    console.log(pc2.yellow("No tools, resources, or prompts found."));
     return;
   }
   if (!process.stdin.isTTY) {
-    console.log(pc.bold("\n  Server Capabilities\n"));
+    console.log(pc2.bold("\n  Server Capabilities\n"));
     for (let i = 0; i < choices.length; i++) {
       console.log(
-        `  ${pc.cyan(String(i + 1).padStart(2))}. ${choices[i].name}  ${pc.dim(choices[i].description)}`
+        `  ${pc2.cyan(String(i + 1).padStart(2))}. ${choices[i].name}  ${pc2.dim(choices[i].description)}`
       );
     }
     console.log();
     console.log(
-      pc.dim("  Non-interactive mode \u2014 use specific commands instead (e.g., tools/call <name>).")
+      pc2.dim("  Non-interactive mode \u2014 use specific commands instead (e.g., tools/call <name>).")
     );
     return;
   }
@@ -2406,163 +3362,30 @@ async function cmdExplore(target, interceptor) {
       source: async (term) => {
         if (!term) return choices;
         const lower = term.toLowerCase();
-        return choices.filter(
-          (c) => c.name.toLowerCase().includes(lower) || c.description.toLowerCase().includes(lower)
-        );
-      }
-    });
-    if (answer.type === "tool") {
-      await cmdToolsCall(target, interceptor, answer.name);
-    } else if (answer.type === "resource") {
-      await cmdResourcesRead(target, answer.uri);
-    } else if (answer.type === "prompt") {
-      await cmdPromptsGet(target, answer.name);
-    }
-  } catch (err) {
-    if (!isAbortError(err)) {
-      throw err;
-    }
-  }
-}
-
-// src/server.ts
-import { createHash } from "crypto";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// src/config-scanner.ts
-import { existsSync } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { homedir } from "os";
-import path from "path";
-import process2 from "process";
-import { input as input2, select as select2 } from "@inquirer/prompts";
-function getConfigPaths() {
-  const home = homedir();
-  const cwd = process2.cwd();
-  const isWin = process2.platform === "win32";
-  const isMac = process2.platform === "darwin";
-  const appData = process2.env.APPDATA || path.join(home, "AppData", "Roaming");
-  const localAppData = process2.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
-  let claudeDesktopGlob;
-  if (isWin) {
-    claudeDesktopGlob = path.join(appData, "Claude", "claude_desktop_config.json");
-  } else if (isMac) {
-    claudeDesktopGlob = path.join(
-      home,
-      "Library",
-      "Application Support",
-      "Claude",
-      "claude_desktop_config.json"
-    );
-  } else {
-    claudeDesktopGlob = path.join(home, ".config", "Claude", "claude_desktop_config.json");
-  }
-  return [
-    { source: "Cursor (Global)", file: path.join(home, ".cursor", "mcp.json") },
-    { source: "Cursor (Project)", file: path.join(cwd, ".cursor", "mcp.json") },
-    { source: "Windsurf", file: path.join(home, ".codeium", "windsurf", "mcp_config.json") },
-    { source: "Claude Desktop", file: claudeDesktopGlob },
-    { source: "Cline", file: path.join(home, "Documents", "Cline", "MCP", "mcp.json") },
-    { source: "VS Code (Project)", file: path.join(cwd, ".vscode", "mcp.json") },
-    {
-      source: "VS Code (Global)",
-      file: path.join(
-        isMac ? path.join(home, "Library", "Application Support") : isWin ? appData : path.join(home, ".config"),
-        "Code",
-        "User",
-        "settings.json"
-      )
-    },
-    { source: "Copilot CLI (Global)", file: path.join(home, ".copilot", "mcp-config.json") },
-    { source: "Gemini CLI (Global)", file: path.join(home, ".gemini", "settings.json") },
-    { source: "Gemini CLI (Project)", file: path.join(cwd, ".gemini", "settings.json") },
-    { source: "Claude Code (Global)", file: path.join(home, ".claude.json") },
-    { source: "Claude Code (Project)", file: path.join(cwd, ".mcp.json") },
-    { source: "Antigravity", file: path.join(home, ".gemini", "antigravity", "mcp_config.json") }
-  ];
-}
-async function discoverServers() {
-  const servers = [];
-  const paths = getConfigPaths();
-  for (const { source, file } of paths) {
-    if (!existsSync(file)) continue;
-    try {
-      const content = await readFile2(file, "utf8");
-      const json = JSON.parse(content);
-      let mcpServers;
-      if (json.mcpServers && typeof json.mcpServers === "object") {
-        mcpServers = json.mcpServers;
-      } else if (json.mcp?.servers && typeof json.mcp.servers === "object") {
-        mcpServers = json.mcp.servers;
-      } else if (json.servers && typeof json.servers === "object") {
-        mcpServers = json.servers;
-      }
-      if (mcpServers) {
-        for (const [name, config] of Object.entries(mcpServers)) {
-          if (config.command) {
-            servers.push({ name, config, source });
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  return servers;
-}
-async function pickDiscoveredServer() {
-  const servers = await discoverServers();
-  if (servers.length === 0) {
-    return null;
-  }
-  const uniqueServers = /* @__PURE__ */ new Map();
-  for (const s of servers) {
-    const key = `${s.name}::${s.config.command}::${(s.config.args || []).join(" ")}`;
-    if (!uniqueServers.has(key)) {
-      uniqueServers.set(key, s);
-    } else {
-      if (s.source.includes("Project")) {
-        uniqueServers.set(key, s);
-      }
-    }
-  }
-  const choices = Array.from(uniqueServers.values()).map((s) => {
-    return {
-      name: `${s.name} (from ${s.source})`,
-      value: s,
-      description: `${s.config.command} ${(s.config.args || []).join(" ")}`
-    };
-  });
-  choices.push({
-    name: "Enter custom server command...",
-    value: "CUSTOM",
-    description: "Manually specify a command, e.g. 'npx foo' or 'python server.py'"
-  });
-  try {
-    const answer = await select2({
-      message: "Select an MCP server to launch:",
-      choices,
-      pageSize: 15
+        return choices.filter(
+          (c) => c.name.toLowerCase().includes(lower) || c.description.toLowerCase().includes(lower)
+        );
+      }
     });
-    if (answer === "CUSTOM") {
-      const customCommand = await input2({ message: "Command to spawn target MCP server:" });
-      if (!customCommand.trim()) return null;
-      const parts = customCommand.trim().match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((p) => p.replace(/^["']|["']$/g, ""));
-      if (!parts || parts.length === 0) return null;
-      return {
-        name: "Custom",
-        config: { command: parts[0], args: parts.slice(1) },
-        source: "Manual"
-      };
+    if (answer.type === "tool") {
+      await cmdToolsCall(target, interceptor, answer.name);
+    } else if (answer.type === "resource") {
+      await cmdResourcesRead(target, answer.uri);
+    } else if (answer.type === "prompt") {
+      await cmdPromptsGet(target, answer.name);
+    }
+  } catch (err) {
+    if (!isAbortError(err)) {
+      throw err;
     }
-    return answer;
-  } catch {
-    return null;
   }
 }
 
 // src/server.ts
+import { createHash } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
 function hashDefinition(obj) {
   return createHash("md5").update(JSON.stringify(obj)).digest("hex").slice(0, 12);
 }
@@ -2593,6 +3416,13 @@ function computeResourceDiff(prev, curr) {
   const removed = [...prevUris].filter((u) => !currUris.has(u));
   return { added, removed, modified: [] };
 }
+function computeResourceTemplateDiff(prev, curr) {
+  const prevUris = new Set(prev.map((t) => t.uriTemplate));
+  const currUris = new Set(curr.map((t) => t.uriTemplate));
+  const added = [...currUris].filter((u) => !prevUris.has(u));
+  const removed = [...prevUris].filter((u) => !currUris.has(u));
+  return { added, removed, modified: [] };
+}
 function formatDiffLine(label, diff) {
   const parts = [];
   if (diff.added.length > 0) parts.push(`+${diff.added.length} added`);
@@ -2606,19 +3436,70 @@ function formatDiffLine(label, diff) {
 async function startServer(opts) {
   let target = null;
   let previousSnapshot = null;
+  let cachedSpawnConfig = null;
   const interceptor = new ResponseInterceptor({
     outDir: opts.outDir,
     defaultTimeoutMs: opts.timeoutMs,
-    maxTextLength: opts.maxTextLength
+    maxTextLength: opts.maxTextLength,
+    mediaThresholdKb: opts.mediaThresholdKb
   });
   const mcpServer = new McpServer(
-    { name: "run-mcp", version: "1.4.0" },
+    { name: "run-mcp", version: "1.6.1" },
     {
       capabilities: {
-        tools: {}
+        tools: {},
+        logging: {}
       }
     }
   );
+  function setupTargetListeners(t) {
+    t.on("stderr", (text) => {
+      mcpServer.sendLoggingMessage({
+        level: "info",
+        logger: "target-stderr",
+        data: text
+      }).catch(() => {
+      });
+    });
+    t.on("disconnected", () => {
+      const pid = t.getStatus().pid;
+      mcpServer.sendLoggingMessage({
+        level: "error",
+        logger: "run-mcp",
+        data: `Target server disconnected unexpectedly! (PID: ${pid})`
+      }).catch(() => {
+      });
+    });
+    t.on("notification", (record) => {
+      mcpServer.server.notification({
+        method: record.method,
+        params: record.params
+      }).catch(() => {
+      });
+    });
+    t.on("sampling_request", async ({ request, respond, reject }) => {
+      try {
+        const result = await mcpServer.server.request(
+          { method: "sampling/createMessage", params: request },
+          z.any()
+        );
+        respond(result);
+      } catch (err) {
+        reject(err);
+      }
+    });
+    t.on("elicitation_request", async ({ request, respond, reject }) => {
+      try {
+        const result = await mcpServer.server.request(
+          { method: "elicitation/create", params: request },
+          z.any()
+        );
+        respond(result);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
   async function takeSnapshot() {
     if (!target?.connected) return {};
     const snap = {};
@@ -2645,6 +3526,14 @@ async function startServer(opts) {
         }));
       } catch {
       }
+      try {
+        const { resourceTemplates } = await target.listResourceTemplates();
+        snap.resourceTemplates = resourceTemplates.map((t) => ({
+          uriTemplate: t.uriTemplate,
+          name: t.name ?? ""
+        }));
+      } catch {
+      }
     }
     if (caps.prompts) {
       try {
@@ -2672,6 +3561,17 @@ async function startServer(opts) {
         )
       );
     }
+    if (current.resourceTemplates && previousSnapshot.resourceTemplates) {
+      lines.push(
+        formatDiffLine(
+          "Resource Templates",
+          computeResourceTemplateDiff(
+            previousSnapshot.resourceTemplates,
+            current.resourceTemplates
+          )
+        )
+      );
+    }
     if (current.prompts && previousSnapshot.prompts) {
       lines.push(formatDiffLine("Prompts", computeDiff(previousSnapshot.prompts, current.prompts)));
     }
@@ -2685,29 +3585,59 @@ async function startServer(opts) {
   }
   async function ensureConnected(command, args, env) {
     if (target?.connected) return null;
-    if (!command) {
+    let cmdToUse = command;
+    let argsToUse = args;
+    let envToUse = env;
+    if (!cmdToUse && cachedSpawnConfig) {
+      cmdToUse = cachedSpawnConfig.command;
+      argsToUse = cachedSpawnConfig.args;
+      envToUse = cachedSpawnConfig.env;
+    }
+    if (!cmdToUse) {
       return "Not connected to a target server. Provide command/args to auto-connect, or call connect_to_mcp first.";
     }
     if (target) {
       await target.close();
       target = null;
     }
-    if (env) {
-      for (const [key, value] of Object.entries(env)) {
+    if (envToUse) {
+      for (const [key, value] of Object.entries(envToUse)) {
         process.env[key] = value;
       }
     }
-    target = new TargetManager(command, args ?? []);
-    await target.connect();
+    target = new TargetManager(cmdToUse, argsToUse ?? []);
+    setupTargetListeners(target);
+    try {
+      await target.connect();
+    } catch (err) {
+      await target.close().catch(() => {
+      });
+      target = null;
+      throw err;
+    }
+    cachedSpawnConfig = { command: cmdToUse, args: argsToUse ?? [], env: envToUse };
     return null;
   }
-  async function buildIncludeData(include) {
+  async function buildIncludeData(include, summary = false) {
     if (!target?.connected || include.length === 0) return [];
     const lines = [];
     if (include.includes("tools")) {
       try {
         const { tools } = await target.listTools();
-        lines.push("", "--- Tools ---", JSON.stringify(tools, null, 2));
+        let displayTools = summary ? tools.map((t) => ({ name: t.name, description: t.description })) : tools;
+        let jsonStr = JSON.stringify(displayTools, null, 2);
+        if (!summary && jsonStr.length > 2e4) {
+          displayTools = tools.map((t) => ({ name: t.name, description: t.description }));
+          jsonStr = JSON.stringify(displayTools, null, 2);
+          lines.push(
+            "",
+            "--- Tools ---",
+            jsonStr,
+            "[Note: Full schemas omitted to protect context window. Use list_mcp_primitives with name='tool_name' to inspect schemas individually.]"
+          );
+        } else {
+          lines.push("", "--- Tools ---", jsonStr);
+        }
       } catch (err) {
         lines.push("", "--- Tools ---", `Error: ${err.message}`);
       }
@@ -2715,15 +3645,50 @@ async function startServer(opts) {
     if (include.includes("resources")) {
       try {
         const { resources } = await target.listResources();
-        lines.push("", "--- Resources ---", JSON.stringify(resources, null, 2));
+        let displayResources = summary ? resources.map((r) => ({
+          name: r.name,
+          uri: r.uri,
+          description: r.description
+        })) : resources;
+        let jsonStr = JSON.stringify(displayResources, null, 2);
+        if (!summary && jsonStr.length > 2e4) {
+          displayResources = resources.map((r) => ({
+            name: r.name,
+            uri: r.uri,
+            description: r.description
+          }));
+          jsonStr = JSON.stringify(displayResources, null, 2);
+          lines.push(
+            "",
+            "--- Resources ---",
+            jsonStr,
+            "[Note: Full schemas omitted to protect context window.]"
+          );
+        } else {
+          lines.push("", "--- Resources ---", jsonStr);
+        }
       } catch (err) {
         lines.push("", "--- Resources ---", `Error: ${err.message}`);
       }
     }
+    if (include.includes("resource_templates")) {
+      try {
+        const { resourceTemplates } = await target.listResourceTemplates();
+        const displayTemplates = summary ? resourceTemplates.map((t) => ({
+          name: t.name,
+          uriTemplate: t.uriTemplate,
+          description: t.description
+        })) : resourceTemplates;
+        lines.push("", "--- Resource Templates ---", JSON.stringify(displayTemplates, null, 2));
+      } catch (err) {
+        lines.push("", "--- Resource Templates ---", `Error: ${err.message}`);
+      }
+    }
     if (include.includes("prompts")) {
       try {
         const { prompts } = await target.listPrompts();
-        lines.push("", "--- Prompts ---", JSON.stringify(prompts, null, 2));
+        const displayPrompts = summary ? prompts.map((p) => ({ name: p.name, description: p.description })) : prompts;
+        lines.push("", "--- Prompts ---", JSON.stringify(displayPrompts, null, 2));
       } catch (err) {
         lines.push("", "--- Prompts ---", `Error: ${err.message}`);
       }
@@ -2734,17 +3699,20 @@ async function startServer(opts) {
     "connect_to_mcp",
     {
       title: "Connect to MCP Server",
-      description: "Spawn and connect to a local MCP server process. Use this to test an MCP server you're building. Only one connection at a time \u2014 call disconnect_from_mcp first if already connected. Use the 'include' parameter to get tools/resources/prompts in the response, saving round trips.",
+      description: "Spawn and connect to a local MCP server process. Use this to test an MCP server you're building. Only one connection at a time \u2014 call disconnect_from_mcp first if already connected. Use the 'include' parameter to get tools/resources/prompts/resource_templates in the response, saving round trips.",
       inputSchema: {
         command: z.string().describe("Command to run (e.g. 'node', 'python', 'npx')"),
         args: z.array(z.string()).optional().describe("Arguments to pass (e.g. ['src/index.js'] or ['-y', 'some-server'])"),
         env: z.record(z.string()).optional().describe("Extra environment variables for the child process"),
-        include: z.array(z.enum(["tools", "resources", "prompts"])).optional().describe(
+        include: z.array(z.enum(["tools", "resources", "resource_templates", "prompts"])).optional().describe(
           "Primitives to include in the response. Saves round trips vs calling list_mcp_primitives separately. On reconnect, also shows a diff of what changed since the last connection."
+        ),
+        summary: z.boolean().optional().describe(
+          "If true, returns only the name and description of each primitive (omitting full schemas) when included to save tokens."
         )
       }
     },
-    async ({ command, args, env, include }) => {
+    async ({ command, args, env, include, summary }) => {
       if (target?.connected) {
         return {
           content: [
@@ -2767,7 +3735,16 @@ async function startServer(opts) {
           }
         }
         target = new TargetManager(command, args ?? []);
-        await target.connect();
+        setupTargetListeners(target);
+        try {
+          await target.connect();
+        } catch (err) {
+          await target.close().catch(() => {
+          });
+          target = null;
+          throw err;
+        }
+        cachedSpawnConfig = { command, args: args ?? [], env };
         const status = target.getStatus();
         const caps = target.getServerCapabilities() ?? {};
         const capSummary = [];
@@ -2796,7 +3773,7 @@ async function startServer(opts) {
         }
         previousSnapshot = currentSnapshot;
         if (include && include.length > 0) {
-          lines.push(...await buildIncludeData(include));
+          lines.push(...await buildIncludeData(include, summary));
         }
         const instructions = target.getInstructions();
         if (instructions) {
@@ -2880,17 +3857,21 @@ Check that the command is correct and the server starts without errors. You can
     "list_mcp_primitives",
     {
       title: "List MCP Primitives",
-      description: "List tools, resources, and/or prompts on the connected MCP server. Specify which types to include. Defaults to all available. Use 'name' to filter to a specific item (e.g. describe a single tool's schema).",
+      description: "List tools, resources, resource templates, and/or prompts on the connected MCP server. Specify which types to include. Defaults to all available. Use 'name' to filter to a specific item (e.g. describe a single tool's schema).",
       inputSchema: {
-        type: z.array(z.enum(["tools", "resources", "prompts"])).optional().describe(
+        type: z.array(z.enum(["tools", "resources", "resource_templates", "prompts"])).optional().describe(
           "Which primitives to list. Defaults to all that the server supports. Example: ['tools'] to list only tools."
         ),
         name: z.string().optional().describe(
-          "Filter to a specific item by name. For tools: matches tool name. For resources: matches URI. For prompts: matches prompt name. Returns the full schema/details for just that item."
-        )
+          "Filter to a specific item by name. For tools: matches tool name. For resources: matches URI. For resource templates: matches URI template. For prompts: matches prompt name. Returns the full schema/details for just that item."
+        ),
+        summary: z.boolean().optional().describe(
+          "If true, returns only the name and description of each primitive (omitting full schemas) to save tokens."
+        ),
+        cursor: z.string().optional().describe("Cursor for pagination (returned from a previous list call)")
       }
     },
-    async ({ type, name }) => {
+    async ({ type, name, summary, cursor }) => {
       if (!target?.connected) {
         return {
           content: [
@@ -2903,11 +3884,11 @@ Check that the command is correct and the server starts without errors. You can
         };
       }
       const caps = target.getServerCapabilities() ?? {};
-      const requested = type ?? ["tools", "resources", "prompts"];
+      const requested = type ?? ["tools", "resources", "resource_templates", "prompts"];
       const sections = [];
       if (requested.includes("tools") && caps.tools) {
         try {
-          const result = await target.listTools();
+          const result = await target.listTools({ cursor });
           let tools = result.tools;
           if (name) {
             tools = tools.filter((t) => t.name === name);
@@ -2919,7 +3900,11 @@ Available: ${available}`);
               sections.push("--- Tools ---", JSON.stringify(tools[0], null, 2));
             }
           } else {
-            sections.push("--- Tools ---", JSON.stringify(tools, null, 2));
+            const displayTools = summary ? tools.map((t) => ({ name: t.name, description: t.description })) : tools;
+            sections.push("--- Tools ---", JSON.stringify(displayTools, null, 2));
+          }
+          if (result.nextCursor) {
+            sections.push(`--- Tools Next Cursor: ${result.nextCursor} ---`);
           }
         } catch (err) {
           sections.push("--- Tools ---", `Error: ${err.message}`);
@@ -2927,7 +3912,7 @@ Available: ${available}`);
       }
       if (requested.includes("resources") && caps.resources) {
         try {
-          const result = await target.listResources();
+          const result = await target.listResources({ cursor });
           let resources = result.resources;
           if (name) {
             resources = resources.filter((r) => r.uri === name || r.name === name);
@@ -2942,15 +3927,54 @@ Available: ${available}`
               sections.push("--- Resources ---", JSON.stringify(resources[0], null, 2));
             }
           } else {
-            sections.push("--- Resources ---", JSON.stringify(resources, null, 2));
+            const displayResources = summary ? resources.map((r) => ({
+              name: r.name,
+              uri: r.uri,
+              description: r.description
+            })) : resources;
+            sections.push("--- Resources ---", JSON.stringify(displayResources, null, 2));
+          }
+          if (result.nextCursor) {
+            sections.push(`--- Resources Next Cursor: ${result.nextCursor} ---`);
           }
         } catch (err) {
           sections.push("--- Resources ---", `Error: ${err.message}`);
         }
       }
+      if (requested.includes("resource_templates") && caps.resources) {
+        try {
+          const result = await target.listResourceTemplates({ cursor });
+          let templates = result.resourceTemplates;
+          if (name) {
+            templates = templates.filter((t) => t.uriTemplate === name || t.name === name);
+            if (templates.length === 0) {
+              const available = result.resourceTemplates.map((t) => t.uriTemplate).join(", ");
+              sections.push(
+                "--- Resource Templates ---",
+                `Resource Template "${name}" not found.
+Available: ${available}`
+              );
+            } else {
+              sections.push("--- Resource Templates ---", JSON.stringify(templates[0], null, 2));
+            }
+          } else {
+            const displayTemplates = summary ? templates.map((t) => ({
+              name: t.name,
+              uriTemplate: t.uriTemplate,
+              description: t.description
+            })) : templates;
+            sections.push("--- Resource Templates ---", JSON.stringify(displayTemplates, null, 2));
+          }
+          if (result.nextCursor) {
+            sections.push(`--- Resource Templates Next Cursor: ${result.nextCursor} ---`);
+          }
+        } catch (err) {
+          sections.push("--- Resource Templates ---", `Error: ${err.message}`);
+        }
+      }
       if (requested.includes("prompts") && caps.prompts) {
         try {
-          const result = await target.listPrompts();
+          const result = await target.listPrompts({ cursor });
           let prompts = result.prompts;
           if (name) {
             prompts = prompts.filter((p) => p.name === name);
@@ -2965,7 +3989,11 @@ Available: ${available}`
               sections.push("--- Prompts ---", JSON.stringify(prompts[0], null, 2));
             }
           } else {
-            sections.push("--- Prompts ---", JSON.stringify(prompts, null, 2));
+            const displayPrompts = summary ? prompts.map((p) => ({ name: p.name, description: p.description })) : prompts;
+            sections.push("--- Prompts ---", JSON.stringify(displayPrompts, null, 2));
+          }
+          if (result.nextCursor) {
+            sections.push(`--- Prompts Next Cursor: ${result.nextCursor} ---`);
           }
         } catch (err) {
           sections.push("--- Prompts ---", `Error: ${err.message}`);
@@ -2997,7 +4025,12 @@ Available: ${available}`
         const servers = await discoverServers();
         if (servers.length === 0) {
           return {
-            content: [{ type: "text", text: "No configured MCP servers discovered in common locations." }]
+            content: [
+              {
+                type: "text",
+                text: "No configured MCP servers discovered in common locations."
+              }
+            ]
           };
         }
         const lines = ["Discovered the following MCP server configurations:"];
@@ -3037,28 +4070,40 @@ Available: ${available}`
         name: z.string().describe("Tool name, resource URI, or prompt name"),
         arguments: z.record(z.unknown()).optional().describe("Arguments for the tool or prompt (not used for resources)"),
         // Auto-connect params (only needed if not already connected)
-        command: z.string().optional().describe(
-          "Command to spawn the server (e.g. 'node'). Required if not already connected."
+        auto_connect: z.object({
+          command: z.string().describe("Command to spawn the server (e.g. 'node')."),
+          args: z.array(z.string()).optional().describe("Arguments for the server command (e.g. ['src/index.js'])"),
+          env: z.record(z.string()).optional().describe("Extra environment variables for the server process")
+        }).optional().describe(
+          "Provide this to automatically spawn and connect to a server if not already connected. Required if no active connection exists."
         ),
-        args: z.array(z.string()).optional().describe("Arguments for the server command (e.g. ['src/index.js'])"),
-        env: z.record(z.string()).optional().describe("Extra environment variables for the server process"),
         // Lifecycle
         disconnect_after: z.boolean().optional().describe("Tear down the connection after this call (default: false)"),
-        timeout_ms: z.number().optional().describe("Timeout in ms (only applies to type: 'tool')")
+        timeout_ms: z.number().optional().describe("Timeout in ms (only applies to type: 'tool')"),
+        include_metadata: z.boolean().optional().describe(
+          "Include a structured metadata content item with latency, interception info, and content statistics. Useful for programmatic consumption."
+        ),
+        max_text_length: z.number().optional().describe(
+          "Max text response length before truncation for this call. Use -1 to disable truncation."
+        )
       }
     },
     async ({
       type: primitiveType,
       name,
       arguments: callArgs,
-      command,
-      args,
-      env,
+      auto_connect,
       disconnect_after,
-      timeout_ms
+      timeout_ms,
+      include_metadata,
+      max_text_length
     }) => {
       try {
-        const connectError = await ensureConnected(command, args, env);
+        const connectError = await ensureConnected(
+          auto_connect?.command,
+          auto_connect?.args,
+          auto_connect?.env
+        );
         if (connectError) {
           return {
             content: [{ type: "text", text: connectError }],
@@ -3118,41 +4163,145 @@ Available tools: ${toolNames.join(", ")}`
             } catch {
             }
             const startMs = Date.now();
-            result = await interceptor.callTool(
-              target,
-              name,
-              callArgs ?? {},
-              timeout_ms
-            );
+            let interceptionMeta;
+            if (include_metadata) {
+              const { result: toolResult, metadata } = await interceptor.callToolWithMetadata(
+                target,
+                name,
+                callArgs ?? {},
+                timeout_ms,
+                max_text_length
+              );
+              result = toolResult;
+              interceptionMeta = metadata;
+            } else {
+              result = await interceptor.callTool(
+                target,
+                name,
+                callArgs ?? {},
+                timeout_ms,
+                max_text_length
+              );
+            }
             const elapsedMs = Date.now() - startMs;
             const resultContent = result.content;
-            if (Array.isArray(resultContent) && resultContent.length > 0) {
-              const lastItem = resultContent[resultContent.length - 1];
-              if (lastItem.type === "text") {
-                lastItem.text += ` (${elapsedMs}ms)`;
+            if (include_metadata && Array.isArray(resultContent)) {
+              const meta = {
+                latency_ms: elapsedMs,
+                content_items: resultContent.length,
+                is_error: result.isError === true
+              };
+              if (interceptionMeta) {
+                meta.truncated = interceptionMeta.truncated;
+                meta.images_saved = interceptionMeta.imagesSaved;
+                meta.audio_saved = interceptionMeta.audioSaved;
+                meta.original_size_bytes = interceptionMeta.originalSizeBytes;
               }
+              resultContent.unshift({
+                type: "text",
+                text: `--- metadata ---
+${JSON.stringify(meta)}`
+              });
             }
             break;
           }
           case "resource": {
-            const resourceResult = await target.readResource({ uri: name });
-            result = {
-              content: [
-                { type: "text", text: JSON.stringify(resourceResult.contents, null, 2) }
-              ]
-            };
+            const startMs = Date.now();
+            const resourceResult = await interceptor.readResource(
+              target,
+              { uri: name },
+              timeout_ms,
+              max_text_length
+            );
+            const elapsedMs = Date.now() - startMs;
+            const contentItems = resourceResult.contents.map((c) => {
+              if (c.text !== void 0) {
+                return { type: "text", text: c.text };
+              } else {
+                return { type: "text", text: `[Resource blob: ${c.uri}]` };
+              }
+            });
+            result = { content: contentItems };
+            if (include_metadata) {
+              const meta = {
+                latency_ms: elapsedMs,
+                content_items: contentItems.length,
+                is_error: false
+              };
+              contentItems.unshift({
+                type: "text",
+                text: `--- metadata ---
+${JSON.stringify(meta)}`
+              });
+            }
             break;
           }
           case "prompt": {
-            const promptResult = await target.getPrompt({
-              name,
-              arguments: callArgs ?? {}
-            });
-            result = {
-              content: [
-                { type: "text", text: JSON.stringify(promptResult.messages, null, 2) }
-              ]
-            };
+            try {
+              const { prompts } = await target.listPrompts();
+              const promptNames = prompts.map((p) => p.name);
+              const matchedPrompt = prompts.find((p) => p.name === name);
+              if (!matchedPrompt) {
+                const suggestion = suggestCommand(name, promptNames);
+                const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Prompt "${name}" not found.${hint}
+Available prompts: ${promptNames.join(", ")}`
+                    }
+                  ],
+                  isError: true
+                };
+              }
+            } catch {
+            }
+            const startMs = Date.now();
+            const promptResult = await interceptor.getPrompt(
+              target,
+              {
+                name,
+                arguments: callArgs ?? {}
+              },
+              timeout_ms,
+              max_text_length
+            );
+            const elapsedMs = Date.now() - startMs;
+            const contentItems = [];
+            for (const msg of promptResult.messages) {
+              const role = msg.role;
+              const content = msg.content;
+              const prefix = `[${role.toUpperCase()} MESSAGE]`;
+              if (content.type === "text") {
+                contentItems.push({ type: "text", text: `${prefix}
+${content.text}` });
+              } else if (Array.isArray(content)) {
+                for (const item of content) {
+                  if (item.type === "text") {
+                    contentItems.push({ type: "text", text: `${prefix}
+${item.text}` });
+                  } else {
+                    contentItems.push(item);
+                  }
+                }
+              } else {
+                contentItems.push(content);
+              }
+            }
+            result = { content: contentItems };
+            if (include_metadata) {
+              const meta = {
+                latency_ms: elapsedMs,
+                content_items: contentItems.length,
+                is_error: false
+              };
+              contentItems.unshift({
+                type: "text",
+                text: `--- metadata ---
+${JSON.stringify(meta)}`
+              });
+            }
             break;
           }
         }
@@ -3214,7 +4363,376 @@ Available tools: ${toolNames.join(", ")}`
 }
 
 // src/index.ts
-program.name("run-mcp").description("A smart interactive REPL and live test harness for MCP servers").version("1.4.0").passThroughOptions().allowUnknownOption().argument(
+function requireTargetCommand(targetCommand, subcommandUsage) {
+  if (!activeTargetCommand) {
+    process.stderr.write(`Error: Target server command must be separated by '--'.
+`);
+    process.stderr.write(`This avoids option parsing conflicts.
+
+`);
+    process.stderr.write(`Usage: ${subcommandUsage}
+`);
+    process.exit(2);
+  }
+  return activeTargetCommand;
+}
+var SESSION_DIR = join2(tmpdir2(), "run-mcp", "sessions");
+function getSessionPath(name) {
+  return join2(SESSION_DIR, `${name}.json`);
+}
+async function getSession(name) {
+  const path2 = getSessionPath(name);
+  if (!existsSync2(path2)) return null;
+  try {
+    const data = await readFile3(path2, "utf8");
+    const parsed = JSON.parse(data);
+    try {
+      process.kill(parsed.pid, 0);
+      return parsed;
+    } catch {
+      await rm(path2, { force: true }).catch(() => {
+      });
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function sendDaemonRequest(port, request) {
+  return new Promise((resolve2, reject) => {
+    const socket = createConnection({ port });
+    let buffer = "";
+    socket.on("connect", () => {
+      socket.write(JSON.stringify(request) + "\n");
+    });
+    socket.on("data", (data) => {
+      buffer += data.toString();
+    });
+    socket.on("end", () => {
+      try {
+        const parsed = JSON.parse(buffer);
+        if (parsed.error) {
+          reject(new Error(parsed.error.message));
+        } else {
+          resolve2(parsed.result);
+        }
+      } catch (err) {
+        reject(new Error(`Failed to parse daemon response: ${err}`));
+      }
+    });
+    socket.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function handleHeadlessSession(sessionName, targetCommand, operation, opts, subcommandUsage) {
+  let session = await getSession(sessionName);
+  if (!session) {
+    if (!activeTargetCommand) {
+      process.stderr.write(`Error: Session "${sessionName}" is not running.
+`);
+      process.stderr.write(`Please provide a target command after '--' to start it.
+
+`);
+      process.stderr.write(`Usage: ${subcommandUsage}
+`);
+      process.exit(2);
+    }
+    const target = activeTargetCommand;
+    const binPath = resolve(import.meta.dirname, "./index.js");
+    const daemonProcess = spawn("node", [binPath, "daemon", sessionName, ...target], {
+      detached: true,
+      stdio: "ignore"
+    });
+    daemonProcess.unref();
+    let attempts = 0;
+    while (attempts < 50) {
+      session = await getSession(sessionName);
+      if (session) break;
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      attempts++;
+    }
+    if (!session) {
+      process.stderr.write(
+        `Error: Failed to spawn background daemon for session "${sessionName}".
+`
+      );
+      process.exit(1);
+    }
+  }
+  try {
+    const response = await sendDaemonRequest(session.port, {
+      jsonrpc: "2.0",
+      method: "execute",
+      params: { operation, opts },
+      id: 1
+    });
+    process.stdout.write(`${JSON.stringify(response.result, null, 2)}
+`);
+    process.exit(response.hasError ? 1 : 0);
+  } catch (err) {
+    process.stderr.write(`Error communicating with session daemon: ${err.message}
+`);
+    process.exit(1);
+  }
+}
+function parseHeadlessOpts(opts) {
+  return {
+    outDir: opts.outDir,
+    timeoutMs: opts.timeout ? Number.parseInt(opts.timeout, 10) : void 0,
+    raw: opts.raw,
+    showStderr: opts.showStderr,
+    mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
+  };
+}
+var activeTargetCommand;
+var argvToParse = process.argv;
+var dashDashIndex = process.argv.indexOf("--");
+if (dashDashIndex !== -1) {
+  activeTargetCommand = process.argv.slice(dashDashIndex + 1);
+  argvToParse = [...process.argv.slice(0, dashDashIndex)];
+}
+program.enablePositionalOptions();
+program.command("call").argument("<tool>", "Tool name to call").argument("[json_args]", "JSON arguments for the tool").argument("[target_command...]", "Target server command (after --)").description("Call a tool on a target MCP server and print the result as JSON").option("-o, --out-dir <path>", "Output directory for saved media").option("-t, --timeout <ms>", "Timeout in milliseconds (default: 30000)").option(
+  "-m, --media-threshold <kb>",
+  "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
+).option("--raw", "Print the full result object including metadata").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(
+  async (tool, jsonArgs, targetCommand, opts) => {
+    const operation = { type: "call", tool, args: jsonArgs };
+    const parsedOpts = parseHeadlessOpts(opts);
+    if (opts.session) {
+      await handleHeadlessSession(
+        opts.session,
+        targetCommand,
+        operation,
+        parsedOpts,
+        "run-mcp call <tool> [json_args] -- <server_command...>"
+      );
+    } else {
+      const target = requireTargetCommand(
+        activeTargetCommand ?? targetCommand,
+        "run-mcp call <tool> [json_args] -- <server_command...>"
+      );
+      await runHeadless(target, operation, parsedOpts);
+    }
+  }
+);
+program.command("list-tools").argument("[target_command...]", "Target server command (after --)").description("List all tools on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (targetCommand, opts) => {
+  const operation = { type: "list-tools" };
+  const parsedOpts = parseHeadlessOpts(opts);
+  if (opts.session) {
+    await handleHeadlessSession(
+      opts.session,
+      targetCommand,
+      operation,
+      parsedOpts,
+      "run-mcp list-tools -- <server_command...>"
+    );
+  } else {
+    const target = requireTargetCommand(
+      activeTargetCommand ?? targetCommand,
+      "run-mcp list-tools -- <server_command...>"
+    );
+    await runHeadless(target, operation, parsedOpts);
+  }
+});
+program.command("list-resources").argument("[target_command...]", "Target server command (after --)").description("List all resources on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (targetCommand, opts) => {
+  const operation = { type: "list-resources" };
+  const parsedOpts = parseHeadlessOpts(opts);
+  if (opts.session) {
+    await handleHeadlessSession(
+      opts.session,
+      targetCommand,
+      operation,
+      parsedOpts,
+      "run-mcp list-resources -- <server_command...>"
+    );
+  } else {
+    const target = requireTargetCommand(
+      activeTargetCommand ?? targetCommand,
+      "run-mcp list-resources -- <server_command...>"
+    );
+    await runHeadless(target, operation, parsedOpts);
+  }
+});
+program.command("list-prompts").argument("[target_command...]", "Target server command (after --)").description("List all prompts on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (targetCommand, opts) => {
+  const operation = { type: "list-prompts" };
+  const parsedOpts = parseHeadlessOpts(opts);
+  if (opts.session) {
+    await handleHeadlessSession(
+      opts.session,
+      targetCommand,
+      operation,
+      parsedOpts,
+      "run-mcp list-prompts -- <server_command...>"
+    );
+  } else {
+    const target = requireTargetCommand(
+      activeTargetCommand ?? targetCommand,
+      "run-mcp list-prompts -- <server_command...>"
+    );
+    await runHeadless(target, operation, parsedOpts);
+  }
+});
+program.command("read").argument("<uri>", "Resource URI to read").argument("[target_command...]", "Target server command (after --)").description("Read a resource by URI from a target MCP server").option(
+  "-m, --media-threshold <kb>",
+  "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
+).option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (uri, targetCommand, opts) => {
+  const operation = { type: "read", uri };
+  const parsedOpts = parseHeadlessOpts(opts);
+  if (opts.session) {
+    await handleHeadlessSession(
+      opts.session,
+      targetCommand,
+      operation,
+      parsedOpts,
+      "run-mcp read <uri> -- <server_command...>"
+    );
+  } else {
+    const target = requireTargetCommand(
+      activeTargetCommand ?? targetCommand,
+      "run-mcp read <uri> -- <server_command...>"
+    );
+    await runHeadless(target, operation, parsedOpts);
+  }
+});
+program.command("describe").argument("<tool>", "Tool name to describe").argument("[target_command...]", "Target server command (after --)").description("Print a tool's full schema as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (tool, targetCommand, opts) => {
+  const operation = { type: "describe", tool };
+  const parsedOpts = parseHeadlessOpts(opts);
+  if (opts.session) {
+    await handleHeadlessSession(
+      opts.session,
+      targetCommand,
+      operation,
+      parsedOpts,
+      "run-mcp describe <tool> -- <server_command...>"
+    );
+  } else {
+    const target = requireTargetCommand(
+      activeTargetCommand ?? targetCommand,
+      "run-mcp describe <tool> -- <server_command...>"
+    );
+    await runHeadless(target, operation, parsedOpts);
+  }
+});
+program.command("get-prompt").argument("<name>", "Prompt name").argument("[json_args]", "JSON arguments for the prompt").argument("[target_command...]", "Target server command (after --)").description("Get a prompt with optional arguments from a target MCP server").option(
+  "-m, --media-threshold <kb>",
+  "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
+).option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(
+  async (name, jsonArgs, targetCommand, opts) => {
+    const operation = { type: "get-prompt", name, args: jsonArgs };
+    const parsedOpts = parseHeadlessOpts(opts);
+    if (opts.session) {
+      await handleHeadlessSession(
+        opts.session,
+        targetCommand,
+        operation,
+        parsedOpts,
+        "run-mcp get-prompt <name> [json_args] -- <server_command...>"
+      );
+    } else {
+      const target = requireTargetCommand(
+        activeTargetCommand ?? targetCommand,
+        "run-mcp get-prompt <name> [json_args] -- <server_command...>"
+      );
+      await runHeadless(target, operation, parsedOpts);
+    }
+  }
+);
+program.command("daemon").argument("<session_name>", "Session name").argument("[target_command...]", "Target server command").description("Start run-mcp in background session daemon mode").allowUnknownOption().action(async (sessionName, targetCommand) => {
+  const targetCmd = activeTargetCommand ?? targetCommand;
+  if (!targetCmd || targetCmd.length === 0) {
+    process.stderr.write("Error: No target command provided for daemon.\n");
+    process.exit(1);
+  }
+  const server = createServer();
+  server.listen(0, "127.0.0.1", async () => {
+    const addr = server.address();
+    const port = addr.port;
+    const target = new TargetManager(targetCmd[0], targetCmd.slice(1));
+    const interceptor = new ResponseInterceptor();
+    try {
+      await target.connect();
+    } catch (err) {
+      process.stderr.write(`Daemon failed to connect to target: ${err.message}
+`);
+      process.exit(1);
+    }
+    await mkdir2(SESSION_DIR, { recursive: true });
+    await writeFile2(
+      getSessionPath(sessionName),
+      JSON.stringify({ port, pid: process.pid }),
+      "utf8"
+    );
+    server.on("connection", (socket) => {
+      let buffer = "";
+      socket.on("data", async (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const req = JSON.parse(trimmed);
+            if (req.method === "execute") {
+              const { operation, opts } = req.params;
+              const { result, hasError } = await executeOperation(
+                target,
+                interceptor,
+                operation,
+                opts
+              );
+              socket.write(
+                JSON.stringify({ jsonrpc: "2.0", result: { result, hasError }, id: req.id }) + "\n"
+              );
+              socket.end();
+            } else if (req.method === "close") {
+              socket.write(
+                JSON.stringify({ jsonrpc: "2.0", result: { ok: true }, id: req.id }) + "\n"
+              );
+              socket.end();
+              await target.close().catch(() => {
+              });
+              await rm(getSessionPath(sessionName), { force: true }).catch(() => {
+              });
+              process.exit(0);
+            }
+          } catch (err) {
+            socket.write(
+              JSON.stringify({ jsonrpc: "2.0", error: { message: err.message }, id: 1 }) + "\n"
+            );
+            socket.end();
+          }
+        }
+      });
+    });
+  });
+});
+program.command("close-session").argument("<session_name>", "Session name").description("Stop a running session daemon").action(async (sessionName) => {
+  const session = await getSession(sessionName);
+  if (!session) {
+    console.log(`Session "${sessionName}" is not running.`);
+    return;
+  }
+  try {
+    await sendDaemonRequest(session.port, {
+      jsonrpc: "2.0",
+      method: "close",
+      params: {},
+      id: 1
+    });
+    console.log(`Session "${sessionName}" stopped successfully.`);
+  } catch {
+    try {
+      process.kill(session.pid, "SIGTERM");
+      console.log(`Session "${sessionName}" stopped (SIGTERM).`);
+    } catch {
+      console.log(`Failed to stop session "${sessionName}".`);
+    }
+  }
+});
+program.name("run-mcp").description("A smart interactive REPL and live test harness for MCP servers").version("1.6.1").passThroughOptions().allowUnknownOption().argument(
   "[target_command...]",
   "Command to spawn the target MCP server (starts REPL if provided, Agent server otherwise)"
 ).option("-o, --out-dir <path>", "Directory to save intercepted images and audio").option(
@@ -3223,16 +4741,28 @@ program.name("run-mcp").description("A smart interactive REPL and live test harn
 ).option(
   "--max-text <chars>",
   "Max text response length before truncation (default: 50000) (Agent Mode only)"
+).option(
+  "-m, --media-threshold <kb>",
+  "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
 ).option("--mcp", "Force start Agent Server mode even if run interactively without arguments").option("-s, --script <file>", "Read commands from a file instead of stdin (REPL Mode only)").addHelpText(
   "after",
   `
 Examples:
   $ run-mcp                                       # Test harness (agent mode)
-  $ run-mcp node my-server.js                     # Interactive testing (human REPL mode)
-  $ run-mcp node my-server.js -s test.txt         # Run a script in REPL mode
-  $ run-mcp npx -y some-mcp-server                # Test an npx server
+  $ run-mcp -- node my-server.js                  # Interactive testing (human REPL mode)
+  $ run-mcp -s test.txt -- node my-server.js      # Run a script in REPL mode
+  $ run-mcp -- npx -y some-mcp-server             # Test an npx server
   $ run-mcp --out-dir ./test-output               # Agent mode with options
-  $ run-mcp --out-dir ./screenshots node srv.js   # REPL mode with options
+  $ run-mcp --out-dir ./screenshots -- node srv.js # REPL mode with options
+
+Headless Commands (pipe-friendly, JSON output):
+  $ run-mcp call echo '{"text":"hi"}' -- node my-server.js
+  $ run-mcp list-tools -- node my-server.js | jq '.[].name'
+  $ run-mcp list-resources -- node my-server.js
+  $ run-mcp list-prompts -- node my-server.js
+  $ run-mcp read docs://readme -- node my-server.js
+  $ run-mcp describe echo -- node my-server.js
+  $ run-mcp get-prompt greeting '{"name":"Ada"}' -- node my-server.js
 
 Agent Mode Configuration (mcp.json):
   {
@@ -3279,14 +4809,26 @@ REPL Mode Commands (once connected):
 Shortcuts: tl td tc ts rl rr rt rs ru pl pg (see help for details)`
 ).action(
   async (targetCommand, opts) => {
-    if (targetCommand && targetCommand.length > 0) {
-      await startRepl(targetCommand, { script: opts.script, outDir: opts.outDir });
+    if (targetCommand && targetCommand.length > 0 && !activeTargetCommand) {
+      process.stderr.write(
+        "Error: Target server command must be separated by '--'.\nThis avoids argument parsing ambiguity.\n\nExample:\n  run-mcp -- node my-server.js\n  run-mcp -s script.txt -- node my-server.js\n"
+      );
+      process.exit(1);
+    }
+    const target = activeTargetCommand ?? [];
+    if (target && target.length > 0) {
+      await startRepl(target, {
+        script: opts.script,
+        outDir: opts.outDir,
+        mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
+      });
     } else {
       if (opts.mcp || !process.stdin.isTTY) {
         await startServer({
           outDir: opts.outDir,
           timeoutMs: opts.timeout ? Number.parseInt(opts.timeout, 10) : void 0,
-          maxTextLength: opts.maxText ? Number.parseInt(opts.maxText, 10) : void 0
+          maxTextLength: opts.maxText ? Number.parseInt(opts.maxText, 10) : void 0,
+          mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
         });
       } else {
         const selected = await pickDiscoveredServer();
@@ -3299,10 +4841,11 @@ Shortcuts: tl td tc ts rl rr rt rs ru pl pg (see help for details)`
         }
         await startRepl([selected.config.command, ...selected.config.args || []], {
           script: opts.script,
-          outDir: opts.outDir
+          outDir: opts.outDir,
+          mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
         });
       }
     }
   }
 );
-program.parse();
+program.parse(argvToParse);