run-mcp 1.3.2 → 1.5.0

package/dist/index.js

@@ -6,6 +6,7 @@ import { program } from "commander";
 // src/repl.ts
 import { readFile } from "fs/promises";
 import { createInterface } from "readline";
+import { checkbox, confirm, input, search } from "@inquirer/prompts";
 import pc from "picocolors";
 
 // src/interceptor.ts
@@ -134,14 +135,14 @@ var ResponseInterceptor = class {
 };
 
 // src/parsing.ts
-function parseCommandLine(input) {
-  const spaceIdx = input.indexOf(" ");
+function parseCommandLine(input3) {
+  const spaceIdx = input3.indexOf(" ");
   if (spaceIdx === -1) {
-    return { cmd: input.toLowerCase(), rest: "" };
+    return { cmd: input3.toLowerCase(), rest: "" };
   }
   return {
-    cmd: input.slice(0, spaceIdx).toLowerCase(),
-    rest: input.slice(spaceIdx + 1)
+    cmd: input3.slice(0, spaceIdx).toLowerCase(),
+    rest: input3.slice(spaceIdx + 1)
   };
 }
 function parseCallArgs(rest) {
@@ -178,29 +179,187 @@ function levenshtein(a, b) {
   }
   return dp[m][n];
 }
-function suggestCommand(input, commands, threshold = 0.4) {
+function suggestCommand(input3, commands, threshold = 0.4) {
   let best = null;
   let bestDist = Infinity;
   for (const cmd of commands) {
-    const dist = levenshtein(input, cmd);
+    const dist = levenshtein(input3, cmd);
     if (dist < bestDist) {
       bestDist = dist;
       best = cmd;
     }
   }
-  if (best && bestDist <= Math.ceil(input.length * threshold)) {
+  if (best && bestDist <= Math.ceil(input3.length * threshold)) {
     return best;
   }
   return null;
 }
+function scaffoldArgs(schema) {
+  return JSON.stringify(scaffoldObject(schema), null, 2);
+}
+function scaffoldValue(prop) {
+  switch (prop.type) {
+    case "string":
+      return "<string>";
+    case "number":
+    case "integer":
+      return "<number>";
+    case "boolean":
+      return "<boolean>";
+    case "array": {
+      const items = prop.items;
+      return items ? [scaffoldValue(items)] : ["<item>"];
+    }
+    case "object":
+      return scaffoldObject(prop);
+    default:
+      return `<${prop.type ?? "unknown"}>`;
+  }
+}
+function scaffoldObject(schema) {
+  const properties = schema.properties;
+  if (!properties) return {};
+  const result = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    result[key] = scaffoldValue(prop);
+  }
+  return result;
+}
+function formatToolDescription(tool) {
+  const lines = [];
+  lines.push(`  ${tool.name}`);
+  if (tool.description) {
+    lines.push(`  ${tool.description}`);
+  }
+  const schema = tool.inputSchema ?? {};
+  const properties = schema.properties;
+  const required = schema.required ?? [];
+  if (properties && Object.keys(properties).length > 0) {
+    lines.push("");
+    lines.push("  Arguments:");
+    const nameWidth = Math.max(6, ...Object.keys(properties).map((n) => n.length));
+    const typeWidth = Math.max(4, ...Object.values(properties).map((p) => typeLabel(p).length));
+    for (const [name, prop] of Object.entries(properties)) {
+      const type = typeLabel(prop);
+      const req = required.includes(name) ? "(required)" : "(optional)";
+      const desc = prop.description ?? "";
+      lines.push(
+        `    ${name.padEnd(nameWidth)}  ${type.padEnd(typeWidth)}  ${req.padEnd(10)}  ${desc}`
+      );
+    }
+  } else {
+    lines.push("");
+    lines.push("  No arguments required.");
+  }
+  lines.push("");
+  lines.push("  Example:");
+  if (properties && Object.keys(properties).length > 0) {
+    const example = scaffoldObject(schema);
+    lines.push(`    tools/call ${tool.name} ${JSON.stringify(example)}`);
+  } 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}`);
+    }
+    lines.push(`    ${annotationParts.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function typeLabel(prop) {
+  const type = prop.type;
+  if (!type) return "any";
+  if (type === "array") {
+    const items = prop.items;
+    return items ? `${typeLabel(items)}[]` : "array";
+  }
+  return type;
+}
+function groupToolsByPrefix(toolNames) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of toolNames) {
+    const underscoreIdx = name.indexOf("_");
+    const prefix = underscoreIdx > 0 ? name.slice(0, underscoreIdx) : name;
+    const list = groups.get(prefix) ?? [];
+    list.push(name);
+    groups.set(prefix, list);
+  }
+  const meaningfulGroups = [...groups.entries()].filter(([, members]) => members.length >= 2);
+  if (meaningfulGroups.length < 2) {
+    const all = /* @__PURE__ */ new Map();
+    all.set("All", [...toolNames]);
+    return all;
+  }
+  const result = /* @__PURE__ */ new Map();
+  const other = [];
+  for (const [prefix, members] of groups) {
+    if (members.length >= 2) {
+      const label = prefix.charAt(0).toUpperCase() + prefix.slice(1);
+      result.set(label, members);
+    } else {
+      other.push(...members);
+    }
+  }
+  if (other.length > 0) {
+    result.set("Other", other);
+  }
+  return result;
+}
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency"
+];
+var ALIASES = {
+  tl: "tools/list",
+  td: "tools/describe",
+  tc: "tools/call",
+  ts: "tools/scaffold",
+  rl: "resources/list",
+  rr: "resources/read",
+  rt: "resources/templates",
+  rs: "resources/subscribe",
+  ru: "resources/unsubscribe",
+  pl: "prompts/list",
+  pg: "prompts/get"
+};
+function resolveAlias(input3) {
+  const spaceIdx = input3.indexOf(" ");
+  const token = spaceIdx === -1 ? input3 : input3.slice(0, spaceIdx);
+  const rest = spaceIdx === -1 ? "" : input3.slice(spaceIdx);
+  const expanded = ALIASES[token.toLowerCase()];
+  if (!expanded) return null;
+  return expanded + rest;
+}
 
 // src/target-manager.ts
 import { EventEmitter } from "events";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import {
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ListRootsRequestSchema,
+  LoggingMessageNotificationSchema,
+  PromptListChangedNotificationSchema,
+  ResourceListChangedNotificationSchema,
+  ResourceUpdatedNotificationSchema,
+  ToolListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
 var MIN_UPTIME_FOR_RESTART_MS = 5e3;
 var MAX_RECONNECT_ATTEMPTS = 3;
 var STABLE_CONNECTION_RESET_MS = 6e4;
+var MAX_HISTORY = 100;
 var TargetManager = class _TargetManager extends EventEmitter {
   constructor(command, args) {
     super();
@@ -223,6 +382,14 @@ var TargetManager = class _TargetManager extends EventEmitter {
   _autoReconnect = false;
   _reconnecting = false;
   _intentionalClose = false;
+  // Request history
+  _history = [];
+  _historyIdCounter = 0;
+  // Notifications
+  _notifications = [];
+  static MAX_NOTIFICATIONS = 200;
+  // Roots
+  _roots = [];
   /**
    * Enable auto-reconnect behavior.
    * Only applies to interactive REPL mode — proxy mode manages its own lifecycle.
@@ -235,24 +402,126 @@ var TargetManager = class _TargetManager extends EventEmitter {
    * Stderr from the child process is emitted as 'stderr' events.
    */
   async connect() {
-    this.transport = new StdioClientTransport({
-      command: this.command,
-      args: this.args,
-      stderr: "pipe"
-    });
-    this.transport.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._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.emit("stderr", text);
+        }
+      });
+      this.transport = stdioTransport;
+    }
+    this.client = new Client(
+      { name: "run-mcp", version: "1.4.0" },
+      {
+        capabilities: {
+          roots: { listChanged: true },
+          sampling: {},
+          elicitation: {}
         }
-        this.emit("stderr", text);
       }
+    );
+    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(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) => {
+        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((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.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(ListRootsRequestSchema, async () => {
+      return { roots: this._roots };
     });
-    this.client = new Client({ name: "run-mcp", version: "1.3.1" }, { capabilities: {} });
     this.client.onclose = () => {
       this._connected = false;
       this._clearStableTimer();
@@ -268,6 +537,8 @@ var TargetManager = class _TargetManager extends EventEmitter {
     const proc = this.transport._process;
     if (proc?.pid) {
       this.childPid = proc.pid;
+    } else {
+      this.childPid = null;
     }
     this.emit("connected");
     this._registerCleanup();
@@ -297,6 +568,26 @@ var TargetManager = class _TargetManager extends EventEmitter {
   getInstructions() {
     return this.client?.getInstructions();
   }
+  /**
+   * Returns the target server's name and version from the MCP handshake.
+   * Available after connect() completes.
+   */
+  getServerVersion() {
+    return this.client?.getServerVersion();
+  }
+  // ─── Ping ──────────────────────────────────────────────────────────────────
+  /**
+   * Send a ping to the target MCP server and return the round-trip time.
+   */
+  async ping() {
+    this._assertConnected();
+    const start = Date.now();
+    await this.client.ping();
+    const elapsed = Date.now() - start;
+    this.recordResponse();
+    this._addHistory("ping", void 0, { ok: true }, elapsed);
+    return elapsed;
+  }
   // ─── Tools ──────────────────────────────────────────────────────────────────
   /**
    * List all tools exposed by the target MCP server.
@@ -304,8 +595,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async listTools(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.listTools(params);
     this.recordResponse();
+    this._addHistory("tools/list", params, result, Date.now() - start);
     return result;
   }
   /**
@@ -318,8 +611,14 @@ var TargetManager = class _TargetManager extends EventEmitter {
   async callTool(name, args = {}, _timeoutMs) {
     this._assertConnected();
     const requestOptions = { timeout: 36e5 * 10 };
-    const result = await this.client.callTool({ name, arguments: args }, void 0, requestOptions);
+    const start = Date.now();
+    const result = await this.client.callTool(
+      { name, arguments: args },
+      void 0,
+      requestOptions
+    );
     this.recordResponse();
+    this._addHistory(`tools/call ${name}`, args, result, Date.now() - start);
     return result;
   }
   // ─── Resources ──────────────────────────────────────────────────────────────
@@ -329,8 +628,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async listResources(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.listResources(params);
     this.recordResponse();
+    this._addHistory("resources/list", params, result, Date.now() - start);
     return result;
   }
   /**
@@ -339,8 +640,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async listResourceTemplates(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.listResourceTemplates(params);
     this.recordResponse();
+    this._addHistory("resources/templates/list", params, result, Date.now() - start);
     return result;
   }
   /**
@@ -348,8 +651,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async readResource(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.readResource(params);
     this.recordResponse();
+    this._addHistory(`resources/read ${params.uri}`, params, result, Date.now() - start);
     return result;
   }
   /**
@@ -357,8 +662,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async subscribeResource(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.subscribeResource(params);
     this.recordResponse();
+    this._addHistory(`resources/subscribe ${params.uri}`, params, result, Date.now() - start);
     return result;
   }
   /**
@@ -366,8 +673,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async unsubscribeResource(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.unsubscribeResource(params);
     this.recordResponse();
+    this._addHistory(`resources/unsubscribe ${params.uri}`, params, result, Date.now() - start);
     return result;
   }
   // ─── Prompts ────────────────────────────────────────────────────────────────
@@ -377,8 +686,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async listPrompts(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.listPrompts(params);
     this.recordResponse();
+    this._addHistory("prompts/list", params, result, Date.now() - start);
     return result;
   }
   /**
@@ -386,8 +697,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async getPrompt(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.getPrompt(params);
     this.recordResponse();
+    this._addHistory(`prompts/get ${params.name}`, params, result, Date.now() - start);
     return result;
   }
   // ─── Logging ────────────────────────────────────────────────────────────────
@@ -396,8 +709,10 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async setLoggingLevel(level) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.setLoggingLevel(level);
     this.recordResponse();
+    this._addHistory(`logging/setLevel ${level}`, { level }, result, Date.now() - start);
     return result;
   }
   // ─── Completion ─────────────────────────────────────────────────────────────
@@ -406,10 +721,96 @@ var TargetManager = class _TargetManager extends EventEmitter {
    */
   async complete(params) {
     this._assertConnected();
+    const start = Date.now();
     const result = await this.client.complete(params);
     this.recordResponse();
+    this._addHistory("completion/complete", params, result, Date.now() - start);
     return result;
   }
+  // ─── Request History ────────────────────────────────────────────────────────
+  /**
+   * Get the request/response history.
+   * @param count - Number of recent records to return (default: all)
+   */
+  getHistory(count) {
+    if (!count || count >= this._history.length) return [...this._history];
+    return this._history.slice(-count);
+  }
+  /**
+   * Clear the history buffer.
+   */
+  clearHistory() {
+    this._history = [];
+  }
+  _addHistory(method, params, result, durationMs) {
+    const record = {
+      id: ++this._historyIdCounter,
+      method,
+      params,
+      result,
+      durationMs,
+      timestamp: Date.now()
+    };
+    this._history.push(record);
+    if (this._history.length > MAX_HISTORY) {
+      this._history = this._history.slice(-MAX_HISTORY);
+    }
+  }
+  // ─── Notification History ───────────────────────────────────────────────────
+  /**
+   * Get recent server notifications.
+   * @param count - Number of recent notifications to return (default: all)
+   */
+  getNotifications(count) {
+    if (!count || count >= this._notifications.length) return [...this._notifications];
+    return this._notifications.slice(-count);
+  }
+  /**
+   * Clear the notification buffer.
+   */
+  clearNotifications() {
+    this._notifications = [];
+  }
+  _pushNotification(record) {
+    this._notifications.push(record);
+    if (this._notifications.length > _TargetManager.MAX_NOTIFICATIONS) {
+      this._notifications = this._notifications.slice(-_TargetManager.MAX_NOTIFICATIONS);
+    }
+  }
+  // ─── Roots Management ─────────────────────────────────────────────────────
+  /**
+   * Get the current roots list that this client advertises.
+   */
+  getRoots() {
+    return [...this._roots];
+  }
+  /**
+   * Add a root and send notification to the server.
+   */
+  async addRoot(root) {
+    if (this._roots.some((r) => r.uri === root.uri)) return;
+    this._roots.push(root);
+    await this._sendRootsChanged();
+  }
+  /**
+   * Remove a root by URI and send notification to the server.
+   */
+  async removeRoot(uri) {
+    const before = this._roots.length;
+    this._roots = this._roots.filter((r) => r.uri !== uri);
+    if (this._roots.length < before) {
+      await this._sendRootsChanged();
+      return true;
+    }
+    return false;
+  }
+  async _sendRootsChanged() {
+    if (!this._connected || !this.client) return;
+    try {
+      await this.client.sendRootsListChanged();
+    } catch {
+    }
+  }
   // ─── Notification forwarding ────────────────────────────────────────────────
   /**
    * Access the underlying MCP client for advanced use cases like
@@ -566,18 +967,199 @@ var TargetManager = class _TargetManager extends EventEmitter {
 
 // src/repl.ts
 var KNOWN_COMMANDS = [
+  "explore",
+  "interactive",
   "tools/list",
   "tools/describe",
   "tools/call",
+  "tools/scaffold",
+  "tools/forget",
+  "resources/list",
+  "resources/read",
+  "resources/templates",
+  "resources/subscribe",
+  "resources/unsubscribe",
+  "prompts/list",
+  "prompts/get",
+  "ping",
+  "log-level",
+  "history",
+  "notifications",
+  "roots/list",
+  "roots/add",
+  "roots/remove",
+  "timing",
   "status",
+  "reconnect",
+  "!!",
+  "last",
   "help",
   "exit",
-  "quit"
+  "quit",
+  // Short aliases
+  "tl",
+  "td",
+  "tc",
+  "ts",
+  "rl",
+  "rr",
+  "rt",
+  "rs",
+  "ru",
+  "pl",
+  "pg"
 ];
+var cachedToolNames = [];
+var cachedResourceUris = [];
+var cachedPromptNames = [];
+async function refreshCaches(target) {
+  const caps = target.getServerCapabilities() ?? {};
+  try {
+    const { tools } = await target.listTools();
+    cachedToolNames = tools.map((t) => t.name);
+  } catch {
+  }
+  if (caps.resources) {
+    try {
+      const { resources } = await target.listResources();
+      cachedResourceUris = resources.map((r) => r.uri);
+    } catch {
+    }
+  }
+  if (caps.prompts) {
+    try {
+      const { prompts } = await target.listPrompts();
+      cachedPromptNames = prompts.map((p) => p.name);
+    } catch {
+    }
+  }
+}
+var tabCycleState = null;
+function resetTabCycle() {
+  tabCycleState = null;
+}
+function computeMatches(line) {
+  const expanded = resolveAlias(line);
+  const effective = expanded ?? line;
+  for (const prefix of ["tools/call ", "tools/describe ", "tools/scaffold "]) {
+    if (effective.startsWith(prefix)) {
+      const partial = effective.slice(prefix.length).split(" ")[0];
+      const matches2 = cachedToolNames.filter((n) => n.startsWith(partial));
+      return [matches2.map((m) => `${prefix}${m}`), effective];
+    }
+  }
+  if (effective.startsWith("resources/read ")) {
+    const partial = effective.slice("resources/read ".length);
+    const matches2 = cachedResourceUris.filter((u) => u.startsWith(partial));
+    return [matches2.map((m) => `resources/read ${m}`), effective];
+  }
+  if (effective.startsWith("prompts/get ")) {
+    const partial = effective.slice("prompts/get ".length).split(" ")[0];
+    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));
+  return [matches, line];
+}
+var completer = (line) => {
+  if (tabCycleState) {
+    const inCycle = line === tabCycleState.original || tabCycleState.matches.includes(line);
+    if (inCycle) {
+      tabCycleState.index = (tabCycleState.index + 1) % tabCycleState.matches.length;
+      const next = tabCycleState.matches[tabCycleState.index];
+      setImmediate(() => {
+        if (activeRl) {
+          activeRl.line = next;
+          activeRl.cursor = next.length;
+          activeRl._refreshLine();
+        }
+      });
+      return [[], ""];
+    }
+    tabCycleState = null;
+  }
+  const [matches, matchLine] = computeMatches(line);
+  if (matches.length > 1) {
+    tabCycleState = { matches, index: -1, original: line };
+  }
+  return [matches, matchLine];
+};
+var callHistory = [];
+var lastToolArgsMap = /* @__PURE__ */ new Map();
+var replHistory = [];
+var lastCommand = null;
+var AbortFlowError = class extends Error {
+  constructor() {
+    super("Aborted by user.");
+    this.name = "AbortFlowError";
+  }
+};
+function isAbortError(err) {
+  if (!err) return false;
+  return err.name === "ExitPromptError" || err.name === "AbortError" || err.message === "Prompt was aborted" || typeof err.message === "string" && err.message.includes("User force closed");
+}
+var activeRl = null;
+var isScriptMode = false;
+var globalPauseReadlineClose = false;
+var deferNextPrompt = false;
+async function withSuspendedReadline(target, interceptor, fn) {
+  const wasActive = !!activeRl;
+  if (wasActive) {
+    globalPauseReadlineClose = true;
+    activeRl.close();
+    activeRl = null;
+  }
+  try {
+    return await fn();
+  } finally {
+    if (wasActive) {
+      globalPauseReadlineClose = false;
+      if (!isScriptMode) {
+        deferNextPrompt = true;
+        startReadlineLoop(target, interceptor);
+      }
+    }
+  }
+}
+function getPrompt(target) {
+  if (target.connected) return `${pc.green("\u2713")}${pc.cyan("> ")}`;
+  return `${pc.red("\u2717")}${pc.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;
+  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")}`;
+  };
+  const partsStr = `  ${parts.join(" \u2022 ")}`;
+  console.log();
+  console.log(pc.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(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(""));
+  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();
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
 async function startRepl(targetCommand, opts) {
   const [command, ...args] = targetCommand;
   const target = new TargetManager(command, args);
   const interceptor = new ResponseInterceptor({ outDir: opts.outDir });
+  isScriptMode = !!opts.script;
   target.on("stderr", (text) => {
     for (const line of text.split("\n")) {
       console.error(pc.dim(`[server] ${line}`));
@@ -600,7 +1182,7 @@ async function startRepl(targetCommand, opts) {
   }
   const status = target.getStatus();
   console.log(pc.green(`\u2713 Connected (PID: ${status.pid})`));
-  if (!opts.script) {
+  if (!isScriptMode) {
     target.enableAutoReconnect();
     target.on(
       "reconnecting",
@@ -611,9 +1193,10 @@ async function startRepl(targetCommand, opts) {
         );
       }
     );
-    target.on("reconnected", ({ attempt }) => {
+    target.on("reconnected", async ({ attempt }) => {
       const s = target.getStatus();
       console.log(pc.green(`\u2713 Reconnected (PID: ${s.pid}, attempt ${attempt})`));
+      await refreshCaches(target);
     });
     target.on("reconnect_failed", ({ reason, message }) => {
       console.error(pc.red(`\u2717 ${message}`));
@@ -623,19 +1206,145 @@ async function startRepl(targetCommand, opts) {
         );
       }
     });
+    target.on("notification", (notification) => {
+      const method = notification.method;
+      if (method === "notifications/message") {
+        const lvl = notification.params?.level ?? "info";
+        const data = notification.params?.data ?? "";
+        const text = typeof data === "string" ? data : JSON.stringify(data);
+        console.log(pc.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."));
+        refreshCaches(target).catch(() => {
+        });
+      } else if (method === "notifications/resources/list_changed") {
+        console.log(pc.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(`
+  \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."));
+        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"));
+      const messages = request?.messages ?? [];
+      for (const msg of messages) {
+        const role = msg.role === "user" ? pc.blue("user") : pc.magenta("assistant");
+        const text = msg.content?.text ?? JSON.stringify(msg.content);
+        console.log(pc.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"));
+      if (activeRl) {
+        try {
+          const answer = await question(activeRl, `  ${pc.bold("Approve? [y/N/text]:")} `);
+          const trimmed = answer.trim().toLowerCase();
+          if (trimmed === "y" || trimmed === "yes") {
+            respond({
+              model: "user-approved",
+              role: "assistant",
+              content: { type: "text", text: "Approved by user." }
+            });
+          } else if (trimmed === "n" || trimmed === "no" || trimmed === "") {
+            rejectFn(new Error("Sampling request rejected by user"));
+          } else {
+            respond({
+              model: "user-provided",
+              role: "assistant",
+              content: { type: "text", text: answer.trim() }
+            });
+          }
+        } catch (err) {
+          if (err instanceof AbortFlowError) {
+            rejectFn(new Error("Sampling request rejected by user"));
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        rejectFn(new Error("No interactive terminal available for sampling approval"));
+      }
+    });
+    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"));
+      if (activeRl) {
+        try {
+          const answer = await question(
+            activeRl,
+            `  ${pc.bold("Your response (empty to decline):")} `
+          );
+          if (answer.trim() === "") {
+            respond({ action: "decline" });
+          } else {
+            try {
+              const parsed = JSON.parse(answer.trim());
+              respond({ action: "accept", content: parsed });
+            } catch {
+              respond({ action: "accept", content: { value: answer.trim() } });
+            }
+          }
+        } catch (err) {
+          if (err instanceof AbortFlowError) {
+            respond({ action: "decline" });
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        rejectFn(new Error("No interactive terminal available for elicitation"));
+      }
+    });
   }
+  let toolCount = 0;
+  let resourceCount = 0;
+  let promptCount = 0;
   try {
     const { tools } = await target.listTools();
-    console.log(
-      pc.cyan(`  ${tools.length} tool(s) available. Type ${pc.bold("help")} for commands.
-`)
-    );
+    toolCount = tools.length;
+    const caps = target.getServerCapabilities() ?? {};
+    if (caps.resources) {
+      try {
+        const { resources } = await target.listResources();
+        resourceCount = resources.length;
+      } catch {
+      }
+    }
+    if (caps.prompts) {
+      try {
+        const { prompts } = await target.listPrompts();
+        promptCount = prompts.length;
+      } catch {
+      }
+    }
+    const serverInfo = target.getServerVersion();
+    const serverName = serverInfo?.name ?? "MCP Server";
+    const serverVersion = serverInfo?.version ?? "";
+    printBanner(serverName, serverVersion, toolCount, resourceCount, promptCount);
+    if (toolCount >= 10) {
+      const groups = groupToolsByPrefix(
+        cachedToolNames.length > 0 ? cachedToolNames : tools.map((t) => t.name)
+      );
+      if (!groups.has("All")) {
+        for (const [label, members] of groups) {
+          console.log(`  ${pc.bold(label.padEnd(16))} ${pc.dim(members.join(", "))}`);
+        }
+        console.log();
+      }
+    }
   } catch (err) {
     console.log(pc.yellow(`  Warning: Could not list tools: ${err.message}
 `));
   }
-  const isScript = !!opts.script;
-  if (isScript) {
+  await refreshCaches(target);
+  if (isScriptMode) {
     const lines = await readScriptLines(opts.script);
     for (const line of lines) {
       const trimmed = line.trim();
@@ -653,51 +1362,98 @@ async function startRepl(targetCommand, opts) {
     await target.close();
     process.exit(0);
   } else {
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      prompt: pc.cyan("> "),
-      terminal: true
+    startReadlineLoop(target, interceptor);
+  }
+}
+function startReadlineLoop(target, interceptor) {
+  if (isScriptMode || activeRl) return;
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: getPrompt(target),
+    terminal: true,
+    completer,
+    history: [...replHistory].reverse()
+    // Node's readline history expects newest first
+  });
+  activeRl = rl;
+  if (process.stdin.isTTY) {
+    process.stdin.on("keypress", (_str, key) => {
+      if (!key || key.name !== "tab") {
+        resetTabCycle();
+      }
     });
+  }
+  if (!deferNextPrompt) {
     rl.prompt();
-    let processing = false;
-    const queue = [];
-    const processQueue = async () => {
-      if (processing) return;
-      processing = true;
-      while (queue.length > 0) {
-        const trimmed = queue.shift();
-        try {
-          await handleCommand(trimmed, target, interceptor);
-        } catch (err) {
+  }
+  deferNextPrompt = false;
+  let processing = false;
+  let closed = false;
+  const queue = [];
+  const processQueue = async () => {
+    if (processing) return;
+    processing = true;
+    while (queue.length > 0) {
+      const trimmed = queue.shift();
+      try {
+        await handleCommand(trimmed, target, interceptor);
+      } catch (err) {
+        if (err instanceof AbortFlowError) {
+          console.log(pc.yellow("  Aborted."));
+        } else {
           console.error(pc.red(`\u2717 Error: ${err.message}`));
         }
-        rl.prompt();
       }
-      processing = false;
-    };
-    rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) {
-        rl.prompt();
-        return;
+      if (activeRl) {
+        setImmediate(() => {
+          if (activeRl) {
+            console.log();
+            activeRl.setPrompt(getPrompt(target));
+            activeRl.prompt();
+          }
+        });
       }
-      queue.push(trimmed);
-      processQueue();
-    });
-    rl.on("close", async () => {
+    }
+    processing = false;
+  };
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      if (!closed && activeRl) activeRl.prompt();
+      return;
+    }
+    replHistory.push(trimmed);
+    queue.push(trimmed);
+    processQueue();
+  });
+  rl.on("close", async () => {
+    closed = true;
+    activeRl = null;
+    if (!globalPauseReadlineClose) {
       console.log(pc.dim("\nShutting down..."));
       await target.close();
       process.exit(0);
-    });
-  }
+    }
+  });
 }
-async function handleCommand(input, target, interceptor) {
-  const { cmd, rest } = parseCommandLine(input);
+async function handleCommand(input3, target, interceptor) {
+  const expanded = resolveAlias(input3);
+  const effective = expanded ?? input3;
+  const { cmd, rest } = parseCommandLine(effective);
+  if (cmd !== "!!" && cmd !== "last") {
+    lastCommand = input3;
+  }
   switch (cmd) {
     case "help":
       printHelp();
       return;
+    case "explore":
+    case "interactive":
+      await withSuspendedReadline(target, interceptor, async () => {
+        await cmdExplore(target, interceptor);
+      });
+      return;
     case "tools/list":
       await cmdToolsList(target);
       return;
@@ -707,6 +1463,69 @@ async function handleCommand(input, target, interceptor) {
     case "tools/call":
       await cmdToolsCall(target, interceptor, rest);
       return;
+    case "tools/scaffold":
+      await cmdToolsScaffold(target, rest);
+      return;
+    case "tools/forget":
+      cmdToolsForget(rest);
+      return;
+    case "resources/list":
+      await cmdResourcesList(target);
+      return;
+    case "resources/read":
+      await cmdResourcesRead(target, rest);
+      return;
+    case "resources/templates":
+      await cmdResourcesTemplates(target);
+      return;
+    case "prompts/list":
+      await cmdPromptsList(target);
+      return;
+    case "prompts/get":
+      await cmdPromptsGet(target, rest);
+      return;
+    case "timing":
+      cmdTiming();
+      return;
+    case "ping":
+      await cmdPing(target);
+      return;
+    case "log-level":
+      await cmdLogLevel(target, rest);
+      return;
+    case "history":
+      cmdHistory(target, rest);
+      return;
+    case "notifications":
+      cmdNotifications(target, rest);
+      return;
+    case "resources/subscribe":
+      await cmdResourcesSubscribe(target, rest);
+      return;
+    case "resources/unsubscribe":
+      await cmdResourcesUnsubscribe(target, rest);
+      return;
+    case "roots/list":
+      cmdRootsList(target);
+      return;
+    case "roots/add":
+      await cmdRootsAdd(target, rest);
+      return;
+    case "roots/remove":
+      await cmdRootsRemove(target, rest);
+      return;
+    case "reconnect":
+      await cmdReconnect(target);
+      return;
+    case "!!":
+    case "last":
+      if (lastCommand) {
+        console.log(pc.dim(`  Re-running: ${lastCommand}`));
+        await handleCommand(lastCommand, target, interceptor);
+      } else {
+        console.log(pc.yellow("No previous command to re-run."));
+      }
+      return;
     case "status":
       cmdStatus(target);
       return;
@@ -717,7 +1536,22 @@ async function handleCommand(input, target, interceptor) {
     default: {
       const suggestion = suggestCommand(cmd, KNOWN_COMMANDS);
       if (suggestion) {
-        console.log(pc.yellow(`Unknown command: ${cmd}. Did you mean ${pc.bold(suggestion)}?`));
+        console.log(pc.yellow(`Unknown command: ${cmd}.`));
+        try {
+          await withSuspendedReadline(target, interceptor, async () => {
+            const runIt = await confirm({
+              message: `Did you mean ${pc.bold(suggestion)}?`,
+              default: true
+            });
+            if (runIt) {
+              const rebuiltCommand = rest ? `${suggestion} ${rest}` : suggestion;
+              await handleCommand(rebuiltCommand, target, interceptor);
+            }
+          });
+        } catch (err) {
+          if (!isAbortError(err)) throw err;
+          throw new AbortFlowError();
+        }
       } else {
         console.log(pc.yellow(`Unknown command: ${cmd}. Type ${pc.bold("help")} for usage.`));
       }
@@ -739,32 +1573,71 @@ async function cmdToolsList(target) {
   }
   console.log(pc.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:"));
+      for (const [label, members] of groups) {
+        console.log(`    ${pc.cyan(label.padEnd(16))} ${pc.dim(members.join(", "))}`);
+      }
+    }
+  }
 }
 async function cmdToolsDescribe(target, rest) {
   const name = rest.trim();
   if (!name) {
-    console.log(pc.yellow("Usage: tools/describe <tool_name>"));
+    console.log(pc.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(`
+  Available tools: ${preview.join(", ")}${more}`));
+      console.log(pc.dim(`  Type ${pc.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(pc.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+    const suggestion = suggestCommand(
+      name,
+      tools.map((t) => t.name)
+    );
+    if (suggestion) {
+      console.log(pc.yellow(`Did you mean ${pc.bold(suggestion)}?`));
+    } else {
+      console.log(pc.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+    }
     return;
   }
-  console.log(pc.bold(`
-  ${tool.name}`));
-  if (tool.description) {
-    console.log(pc.dim(`  ${tool.description}`));
-  }
-  console.log(pc.cyan("\n  Input Schema:"));
-  console.log(formatJson(tool.inputSchema, 4));
+  console.log();
+  console.log(
+    formatToolDescription({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      annotations: tool.annotations
+    })
+  );
+  console.log();
 }
 async function cmdToolsCall(target, interceptor, rest) {
-  const { toolName, jsonArgs, timeoutMs } = parseCallArgs(rest);
+  const clearPrevious = /\s--clear(\s|$)/.test(rest) || rest === "--clear";
+  const cleanedRest = clearPrevious ? rest.replace(/\s*--clear/, "").trim() : rest;
+  const { toolName, jsonArgs, timeoutMs } = parseCallArgs(cleanedRest);
   if (!toolName) {
-    console.log(pc.yellow("Usage: tools/call <tool_name> [json_args] [--timeout <ms>]"));
+    console.log(pc.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(`
+  Available tools: ${preview.join(", ")}${more}`));
+      console.log(
+        pc.dim(`  Run without args for ${pc.bold("interactive mode")}: tools/call <name>`)
+      );
+    }
     return;
   }
   let args = {};
@@ -776,16 +1649,56 @@ async function cmdToolsCall(target, interceptor, rest) {
       console.log(pc.dim(`  Received: ${jsonArgs}`));
       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;
+      }
+    }
+  } else {
+    const collectedArgs = await interactiveArgPrompt(target, interceptor, toolName, clearPrevious);
+    if (collectedArgs === null) return;
+    args = collectedArgs;
+    if (!isScriptMode) {
+      const fullCmd = `tools/call ${toolName} ${JSON.stringify(args)}`;
+      replHistory.push(fullCmd);
+      if (activeRl) {
+        activeRl.history.unshift(fullCmd);
+      }
+    }
   }
   console.log(pc.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))}`);
   const content = result.content;
   if (Array.isArray(content)) {
     for (const item of content) {
       if (item.type === "text") {
-        console.log(item.text);
+        console.log(isError ? pc.red(`  \u2717 ${item.text}`) : `  ${item.text}`);
       } else {
         console.log(formatJson(item, 2));
       }
@@ -793,14 +1706,555 @@ async function cmdToolsCall(target, interceptor, rest) {
   } else {
     console.log(formatJson(result, 2));
   }
-  console.log(pc.dim(`  (${elapsed}ms)`));
+  if (isError) {
+    console.log(
+      pc.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")}`);
 }
-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")}`);
+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.`));
+    const suggestion = suggestCommand(
+      toolName,
+      tools.map((t) => t.name)
+    );
+    if (suggestion) {
+      console.log(pc.yellow(`Did you mean ${pc.bold(suggestion)}?`));
+    } else {
+      console.log(pc.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+    }
+    return null;
+  }
+  const schema = tool.inputSchema;
+  const properties = schema.properties;
+  if (!properties || Object.keys(properties).length === 0) {
+    return {};
+  }
+  if (isScriptMode) {
+    console.log(pc.yellow(`  Tool "${toolName}" requires arguments.`));
+    const scaffolded = scaffoldArgs(schema);
+    console.log(pc.dim(`  Usage: tools/call ${toolName} ${scaffolded}`));
+    return null;
+  }
+  const required = schema.required ?? [];
+  const allProps = Object.entries(properties);
+  const requiredProps = allProps.filter(([name]) => required.includes(name));
+  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}`) : ""}`);
+  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();
+  const collectedArgs = {};
+  return await withSuspendedReadline(target, interceptor, async () => {
+    const abortController = new AbortController();
+    const onData = (data) => {
+      if (data.toString() === "\x1B") {
+        abortController.abort();
+      }
+    };
+    process.stdin.on("data", onData);
+    try {
+      for (const [name, prop] of requiredProps) {
+        printJsonTemplate(collectedArgs, allProps, name);
+        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 },
+          { signal: abortController.signal }
+        );
+        collectedArgs[name] = coerceValue(answerStr, typeStr);
+      }
+      if (optionalProps.length > 0) {
+        const previouslyUsedOptionals = previousArgs ? optionalProps.filter(([name]) => name in previousArgs).map(([name]) => name) : [];
+        const selectedNames = await checkbox(
+          {
+            message: "Select optional arguments to provide:",
+            choices: optionalProps.map(([name, prop]) => {
+              const typeStr = prop.type ?? "any";
+              const desc = prop.description ?? "";
+              return {
+                name: desc ? `${name} (${typeStr}) - ${desc}` : `${name} (${typeStr})`,
+                value: name,
+                checked: previouslyUsedOptionals.includes(name)
+              };
+            })
+          },
+          { signal: abortController.signal }
+        );
+        const selectedOptionals = optionalProps.filter(([name]) => selectedNames.includes(name));
+        for (const [name, prop] of selectedOptionals) {
+          printJsonTemplate(collectedArgs, allProps, name);
+          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 },
+            { signal: abortController.signal }
+          );
+          collectedArgs[name] = coerceValue(answerStr, typeStr);
+        }
+      }
+      console.log();
+      console.log(pc.dim(`  ${JSON.stringify(collectedArgs)}`));
+      const shouldExecute = await confirm(
+        { message: "Execute?", default: true },
+        { signal: abortController.signal }
+      );
+      if (!shouldExecute) return null;
+      return collectedArgs;
+    } catch (err) {
+      if (!isAbortError(err)) {
+        throw err;
+      }
+      return null;
+    } finally {
+      process.stdin.off("data", onData);
+    }
+  });
+}
+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]))}`);
+    } else if (name === currentProp) {
+      parts.push(`"${name}": ${pc.yellow("\u2592")}`);
+    } else {
+      parts.push(`"${name}": ${pc.dim("\u2592")}`);
+    }
+  }
+  console.log(pc.dim("  { ") + parts.join(pc.dim(", ")) + pc.dim(" }"));
+  console.log();
+}
+function coerceValue(input3, type) {
+  switch (type) {
+    case "number":
+    case "integer": {
+      const n = Number(input3);
+      return Number.isNaN(n) ? input3 : n;
+    }
+    case "boolean":
+      return input3.toLowerCase() === "true" || input3 === "1";
+    default:
+      return input3;
+  }
+}
+function question(rl, prompt) {
+  return new Promise((resolve, reject) => {
+    let aborted = false;
+    const onKeypress = (_str, key) => {
+      if (key && key.name === "escape") {
+        aborted = true;
+        cleanup();
+        process.stdout.write("\x1B[2K\r");
+        rl.write("", { ctrl: true, name: "u" });
+        rl.write("\n");
+      }
+    };
+    const cleanup = () => {
+      if (process.stdin.isTTY) {
+        process.stdin.removeListener("keypress", onKeypress);
+      }
+    };
+    if (process.stdin.isTTY) {
+      process.stdin.on("keypress", onKeypress);
+    }
+    rl.question(prompt, (answer) => {
+      cleanup();
+      if (aborted) {
+        reject(new AbortFlowError());
+      } else {
+        resolve(answer);
+      }
+    });
+  });
+}
+async function cmdToolsScaffold(target, rest) {
+  const name = rest.trim();
+  if (!name) {
+    console.log(pc.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(`
+  Available tools: ${preview.join(", ")}${more}`));
+    }
+    return;
+  }
+  const { tools } = await target.listTools();
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) {
+    console.log(pc.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)}?`));
+    } else {
+      console.log(pc.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(`  tools/call ${name} ${scaffolded}
+`);
+}
+async function cmdResourcesList(target) {
+  const { resources } = await target.listResources();
+  if (resources.length === 0) {
+    console.log(pc.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)}`));
+  for (const r of resources) {
+    const uri = r.uri;
+    const name = r.name ?? pc.dim("(unnamed)");
+    console.log(`  ${pc.green(uri.padEnd(uriWidth))}  ${name}`);
+  }
+  console.log(pc.dim(`
+  ${resources.length} resource(s) total.`));
+}
+async function cmdResourcesRead(target, rest) {
+  const uri = rest.trim();
+  if (!uri) {
+    console.log(pc.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(`
+  Available resources: ${preview.join(", ")}${more}`));
+    }
+    return;
+  }
+  const result = await target.readResource({ uri });
+  for (const item of result.contents) {
+    if (item.text !== void 0) {
+      console.log(item.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]`));
+    } else {
+      console.log(formatJson(item, 2));
+    }
+  }
+}
+async function cmdResourcesTemplates(target) {
+  const { resourceTemplates } = await target.listResourceTemplates();
+  if (resourceTemplates.length === 0) {
+    console.log(pc.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)}`));
+  for (const t of resourceTemplates) {
+    const uriTemplate = t.uriTemplate;
+    const name = t.name ?? pc.dim("(unnamed)");
+    console.log(`  ${pc.green(uriTemplate.padEnd(uriWidth))}  ${name}`);
+  }
+  console.log(pc.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."));
+    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)}`));
+  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}`);
+  }
+  console.log(pc.dim(`
+  ${prompts.length} prompt(s) total.`));
+}
+async function cmdPromptsGet(target, rest) {
+  const { toolName: promptName, jsonArgs } = parseCallArgs(rest);
+  if (!promptName) {
+    console.log(pc.yellow("  Usage: prompts/get <name> [json_args]"));
+    if (cachedPromptNames.length > 0) {
+      console.log(pc.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 result = await target.getPrompt({ name: promptName, arguments: promptArgs });
+  for (const msg of result.messages) {
+    const role = msg.role === "user" ? pc.blue("user") : pc.magenta("assistant");
+    const text = msg.content.text ?? JSON.stringify(msg.content);
+    console.log(`  ${pc.bold(role)}: ${text}`);
+  }
+}
+async function cmdPing(target) {
+  try {
+    const elapsed = await target.ping();
+    console.log(pc.green(`  \u2713 Pong! Round-trip: ${elapsed}ms`));
+  } catch (err) {
+    console.error(pc.red(`  \u2717 Ping failed: ${err.message}`));
+  }
+}
+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(", ")}`));
+    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(", ")}`));
+    return;
+  }
+  try {
+    await target.setLoggingLevel(level);
+    console.log(pc.green(`  \u2713 Logging level set to: ${level}`));
+  } catch (err) {
+    console.error(pc.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."));
+    }
+  }
+}
+function cmdHistory(target, rest) {
+  const arg = rest.trim();
+  if (arg === "clear") {
+    target.clearHistory();
+    console.log(pc.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."));
+    return;
+  }
+  console.log(pc.bold("\n  Request History"));
+  console.log(pc.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") : "";
+    console.log(
+      `  ${pc.dim(`#${rec.id}`)} ${pc.dim(time)} ${pc.green(rec.method.padEnd(30))} ${pc.cyan(dur.padStart(8))}${hasError}`
+    );
+  }
+  const total = target.getHistory().length;
+  console.log(
+    pc.dim(`
+  Showing ${records.length} of ${total} total. Use "history clear" to reset.`)
+  );
+  console.log();
+}
+function cmdNotifications(target, rest) {
+  const arg = rest.trim();
+  if (arg === "clear") {
+    target.clearNotifications();
+    console.log(pc.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."));
+    return;
+  }
+  console.log(pc.bold("\n  Server Notifications"));
+  console.log(pc.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 total = target.getNotifications().length;
+  console.log(
+    pc.dim(`
+  Showing ${records.length} of ${total} total. Use "notifications clear" to reset.`)
+  );
+  console.log();
+}
+async function cmdResourcesSubscribe(target, rest) {
+  const uri = rest.trim();
+  if (!uri) {
+    console.log(pc.yellow("  Usage: resources/subscribe <uri>"));
+    if (cachedResourceUris.length > 0) {
+      console.log(pc.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."));
+  } catch (err) {
+    console.error(pc.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>"));
+    return;
+  }
+  try {
+    await target.unsubscribeResource({ uri });
+    console.log(pc.green(`  \u2713 Unsubscribed from: ${uri}`));
+  } catch (err) {
+    console.error(pc.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."));
+    return;
+  }
+  console.log(pc.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();
+}
+async function cmdRootsAdd(target, rest) {
+  const parts = rest.trim().split(/\s+/);
+  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"'));
+    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."));
+}
+async function cmdRootsRemove(target, rest) {
+  const uri = rest.trim();
+  if (!uri) {
+    console.log(pc.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(", ")}`));
+    }
+    return;
+  }
+  const removed = await target.removeRoot(uri);
+  if (removed) {
+    console.log(pc.green(`  \u2713 Root removed: ${uri}`));
+  } else {
+    console.log(pc.yellow(`  Root not found: ${uri}`));
+  }
+}
+async function cmdReconnect(target) {
+  console.log(pc.cyan("\u27F3 Disconnecting..."));
+  await target.close();
+  await new Promise((resolve) => setTimeout(resolve, 200));
+  console.log(pc.cyan("\u27F3 Reconnecting..."));
+  const { command, args } = target.getStatus();
+  console.log(pc.dim(`  Command: ${command} ${args.join(" ")}`));
+  try {
+    await target.connect();
+    const s = target.getStatus();
+    console.log(pc.green(`\u2713 Reconnected (PID: ${s.pid})`));
+    const { tools } = await target.listTools();
+    console.log(pc.cyan(`  ${tools.length} tool(s) available.
+`));
+    await refreshCaches(target);
+  } catch (err) {
+    console.error(pc.red(`\u2717 Failed to reconnect: ${err.message}`));
+  }
+}
+function cmdTiming() {
+  if (callHistory.length === 0) {
+    console.log(pc.dim("  No tool calls recorded yet."));
+    return;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const record of callHistory) {
+    const list = groups.get(record.toolName) ?? [];
+    list.push(record.durationMs);
+    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)}`));
+  let totalCalls = 0;
+  let totalMs = 0;
+  let slowestName = "";
+  let slowestMs = 0;
+  for (const [name, durations] of groups) {
+    const count = durations.length;
+    totalCalls += count;
+    const sorted = [...durations].sort((a, b) => a - b);
+    const avg = Math.round(sorted.reduce((a, b) => a + b, 0) / count);
+    const p95 = sorted[Math.floor(count * 0.95)];
+    const max = sorted[sorted.length - 1];
+    totalMs += sorted.reduce((a, b) => a + b, 0);
+    if (max > slowestMs) {
+      slowestMs = max;
+      slowestName = name;
+    }
+    console.log(
+      `  ${pc.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(
+      `
+  Total: ${totalCalls} call(s), avg ${overallAvg}ms, slowest: ${slowestName} (${slowestMs}ms)`
+    )
+  );
+  console.log();
+}
+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}`);
@@ -811,56 +2265,486 @@ function cmdStatus(target) {
 }
 function printHelp() {
   console.log(`
-${pc.bold("Available Commands:")}
+${pc.bold("Tool Commands:")}
 
   ${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 with JSON arguments
+  ${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
+
+${pc.bold("Resource Commands:")}
+
+  ${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
+
+${pc.bold("Prompt Commands:")}
+
+  ${pc.green("prompts/list")}                       List all available prompts
+  ${pc.green("prompts/get")} <name> [json_args]    Get a prompt with arguments
+
+${pc.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
+
+${pc.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
+
+${pc.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
 
+${pc.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
+
 ${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.")}
 `);
 }
 async function readScriptLines(filepath) {
   const content = await readFile(filepath, "utf-8");
   return content.split("\n");
 }
+function cmdToolsForget(rest) {
+  const toolName = rest.trim();
+  if (toolName) {
+    if (lastToolArgsMap.has(toolName)) {
+      lastToolArgsMap.delete(toolName);
+      console.log(pc.green(`  Cleared remembered args for ${pc.bold(toolName)}.`));
+    } else {
+      console.log(pc.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"}.`));
+  }
+}
+async function cmdExplore(target, interceptor) {
+  const choices = [];
+  const caps = target.getServerCapabilities() ?? {};
+  try {
+    const { tools } = await target.listTools();
+    for (const t of tools) {
+      choices.push({
+        name: `\u{1F6E0}\uFE0F  Tool: ${t.name}`,
+        value: { type: "tool", name: t.name },
+        description: t.description || `Call the ${t.name} tool`
+      });
+    }
+  } catch {
+  }
+  if (caps.resources) {
+    try {
+      const { resources } = await target.listResources();
+      for (const r of resources) {
+        choices.push({
+          name: `\u{1F4C4} Resource: ${r.name || r.uri}`,
+          value: { type: "resource", uri: r.uri },
+          description: r.description || `Read resource ${r.uri}`
+        });
+      }
+    } catch {
+    }
+  }
+  if (caps.prompts) {
+    try {
+      const { prompts } = await target.listPrompts();
+      for (const p of prompts) {
+        choices.push({
+          name: `\u{1F4AC} Prompt: ${p.name}`,
+          value: { type: "prompt", name: p.name },
+          description: p.description || `Get the ${p.name} prompt`
+        });
+      }
+    } catch {
+    }
+  }
+  if (choices.length === 0) {
+    console.log(pc.yellow("No tools, resources, or prompts found."));
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    console.log(pc.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)}`
+      );
+    }
+    console.log();
+    console.log(
+      pc.dim("  Non-interactive mode \u2014 use specific commands instead (e.g., tools/call <name>).")
+    );
+    return;
+  }
+  try {
+    const answer = await search({
+      message: "Explore server capabilities:",
+      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
+    });
+    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"
+      };
+    }
+    return answer;
+  } catch {
+    return null;
+  }
+}
+
+// src/server.ts
+function hashDefinition(obj) {
+  return createHash("md5").update(JSON.stringify(obj)).digest("hex").slice(0, 12);
+}
+function computeDiff(prev, curr) {
+  const prevMap = new Map(prev.map((p) => [p.name, p.hash]));
+  const currMap = new Map(curr.map((c) => [c.name, c.hash]));
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [name, hash] of currMap) {
+    if (!prevMap.has(name)) {
+      added.push(name);
+    } else if (prevMap.get(name) !== hash) {
+      modified.push(name);
+    }
+  }
+  for (const name of prevMap.keys()) {
+    if (!currMap.has(name)) {
+      removed.push(name);
+    }
+  }
+  return { added, removed, modified };
+}
+function computeResourceDiff(prev, curr) {
+  const prevUris = new Set(prev.map((r) => r.uri));
+  const currUris = new Set(curr.map((r) => r.uri));
+  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`);
+  if (diff.modified.length > 0) parts.push(`~${diff.modified.length} modified`);
+  if (diff.removed.length > 0) parts.push(`-${diff.removed.length} removed`);
+  if (parts.length === 0) return `  ${label}: unchanged`;
+  const details = parts.join(", ");
+  const names = [...diff.added, ...diff.modified, ...diff.removed];
+  return `  ${label}: ${details} (${names.join(", ")})`;
+}
 async function startServer(opts) {
   let target = null;
+  let previousSnapshot = null;
   const interceptor = new ResponseInterceptor({
     outDir: opts.outDir,
     defaultTimeoutMs: opts.timeoutMs,
     maxTextLength: opts.maxTextLength
   });
   const mcpServer = new McpServer(
-    { name: "run-mcp", version: "1.3.1" },
+    { name: "run-mcp", version: "1.4.0" },
     {
       capabilities: {
         tools: {}
       }
     }
   );
+  async function takeSnapshot() {
+    if (!target?.connected) return {};
+    const snap = {};
+    const caps = target.getServerCapabilities() ?? {};
+    if (caps.tools) {
+      try {
+        const { tools } = await target.listTools();
+        snap.tools = tools.map((t) => ({
+          name: t.name,
+          hash: hashDefinition({
+            description: t.description,
+            inputSchema: t.inputSchema
+          })
+        }));
+      } catch {
+      }
+    }
+    if (caps.resources) {
+      try {
+        const { resources } = await target.listResources();
+        snap.resources = resources.map((r) => ({
+          uri: r.uri,
+          name: r.name ?? ""
+        }));
+      } catch {
+      }
+    }
+    if (caps.prompts) {
+      try {
+        const { prompts } = await target.listPrompts();
+        snap.prompts = prompts.map((p) => ({
+          name: p.name,
+          hash: hashDefinition({ description: p.description })
+        }));
+      } catch {
+      }
+    }
+    return snap;
+  }
+  function computeSnapshotDiff(current) {
+    if (!previousSnapshot) return [];
+    const lines = ["", "Changes since last connection:"];
+    if (current.tools && previousSnapshot.tools) {
+      lines.push(formatDiffLine("Tools", computeDiff(previousSnapshot.tools, current.tools)));
+    }
+    if (current.resources && previousSnapshot.resources) {
+      lines.push(
+        formatDiffLine(
+          "Resources",
+          computeResourceDiff(previousSnapshot.resources, current.resources)
+        )
+      );
+    }
+    if (current.prompts && previousSnapshot.prompts) {
+      lines.push(formatDiffLine("Prompts", computeDiff(previousSnapshot.prompts, current.prompts)));
+    }
+    const hasChanges = lines.some(
+      (l) => l.includes("+") || l.includes("~") || l.includes("-removed")
+    );
+    if (!hasChanges) {
+      return ["", "Changes since last connection: none"];
+    }
+    return lines;
+  }
+  async function ensureConnected(command, args, env) {
+    if (target?.connected) return null;
+    if (!command) {
+      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)) {
+        process.env[key] = value;
+      }
+    }
+    target = new TargetManager(command, args ?? []);
+    await target.connect();
+    return null;
+  }
+  async function buildIncludeData(include) {
+    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));
+      } catch (err) {
+        lines.push("", "--- Tools ---", `Error: ${err.message}`);
+      }
+    }
+    if (include.includes("resources")) {
+      try {
+        const { resources } = await target.listResources();
+        lines.push("", "--- Resources ---", JSON.stringify(resources, null, 2));
+      } catch (err) {
+        lines.push("", "--- Resources ---", `Error: ${err.message}`);
+      }
+    }
+    if (include.includes("prompts")) {
+      try {
+        const { prompts } = await target.listPrompts();
+        lines.push("", "--- Prompts ---", JSON.stringify(prompts, null, 2));
+      } catch (err) {
+        lines.push("", "--- Prompts ---", `Error: ${err.message}`);
+      }
+    }
+    return lines;
+  }
   mcpServer.registerTool(
     "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.",
+      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.",
       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")
+        env: z.record(z.string()).optional().describe("Extra environment variables for the child process"),
+        include: z.array(z.enum(["tools", "resources", "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."
+        )
       }
     },
-    async ({ command, args, env }) => {
+    async ({ command, args, env, include }) => {
       if (target?.connected) {
         return {
           content: [
@@ -903,9 +2787,21 @@ async function startServer(opts) {
           `Capabilities: ${capSummary.join(", ") || "none"}`,
           `Tools available: ${toolCount}`,
           "",
-          "Use list_mcp_tools, call_mcp_tool, list_mcp_resources, etc. to interact with it.",
+          "Use call_mcp_primitive to call tools, read resources, or get prompts.",
           "Use disconnect_from_mcp when done, or to reconnect after code changes."
         ];
+        const currentSnapshot = await takeSnapshot();
+        if (previousSnapshot && include && include.length > 0) {
+          lines.push(...computeSnapshotDiff(currentSnapshot));
+        }
+        previousSnapshot = currentSnapshot;
+        if (include && include.length > 0) {
+          lines.push(...await buildIncludeData(include));
+        }
+        const instructions = target.getInstructions();
+        if (instructions) {
+          lines.push("", "--- Server Instructions ---", instructions);
+        }
         return { content: [{ type: "text", text: lines.join("\n") }] };
       } catch (err) {
         target = null;
@@ -981,12 +2877,20 @@ Check that the command is correct and the server starts without errors. You can
     }
   );
   mcpServer.registerTool(
-    "list_mcp_tools",
+    "list_mcp_primitives",
     {
-      title: "List MCP Tools",
-      description: "List all tools exposed by the connected MCP server, including descriptions, input schemas, and annotations."
+      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).",
+      inputSchema: {
+        type: z.array(z.enum(["tools", "resources", "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."
+        )
+      }
     },
-    async () => {
+    async ({ type, name }) => {
       if (!target?.connected) {
         return {
           content: [
@@ -998,239 +2902,272 @@ Check that the command is correct and the server starts without errors. You can
           isError: true
         };
       }
-      try {
-        const result = await target.listTools();
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result.tools, null, 2)
+      const caps = target.getServerCapabilities() ?? {};
+      const requested = type ?? ["tools", "resources", "prompts"];
+      const sections = [];
+      if (requested.includes("tools") && caps.tools) {
+        try {
+          const result = await target.listTools();
+          let tools = result.tools;
+          if (name) {
+            tools = tools.filter((t) => t.name === name);
+            if (tools.length === 0) {
+              const available = result.tools.map((t) => t.name).join(", ");
+              sections.push("--- Tools ---", `Tool "${name}" not found.
+Available: ${available}`);
+            } else {
+              sections.push("--- Tools ---", JSON.stringify(tools[0], null, 2));
             }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error listing tools: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  mcpServer.registerTool(
-    "describe_mcp_tool",
-    {
-      title: "Describe MCP Tool",
-      description: "Get the description and input schema for a specific tool on the connected server.",
-      inputSchema: {
-        name: z.string().describe("Name of the tool to describe")
-      }
-    },
-    async ({ name }) => {
-      if (!target?.connected) {
-        return {
-          content: [
-            { type: "text", text: "No target server connected. Use connect_to_mcp first." }
-          ],
-          isError: true
-        };
+          } else {
+            sections.push("--- Tools ---", JSON.stringify(tools, null, 2));
+          }
+        } catch (err) {
+          sections.push("--- Tools ---", `Error: ${err.message}`);
+        }
       }
-      try {
-        const result = await target.listTools();
-        const tool = result.tools.find((t) => t.name === name);
-        if (!tool) {
-          const available = result.tools.map((t) => t.name).join(", ");
-          return {
-            content: [
-              { type: "text", text: `Tool "${name}" not found.
-Available tools: ${available}` }
-            ],
-            isError: true
-          };
+      if (requested.includes("resources") && caps.resources) {
+        try {
+          const result = await target.listResources();
+          let resources = result.resources;
+          if (name) {
+            resources = resources.filter((r) => r.uri === name || r.name === name);
+            if (resources.length === 0) {
+              const available = result.resources.map((r) => r.uri).join(", ");
+              sections.push(
+                "--- Resources ---",
+                `Resource "${name}" not found.
+Available: ${available}`
+              );
+            } else {
+              sections.push("--- Resources ---", JSON.stringify(resources[0], null, 2));
+            }
+          } else {
+            sections.push("--- Resources ---", JSON.stringify(resources, null, 2));
+          }
+        } catch (err) {
+          sections.push("--- Resources ---", `Error: ${err.message}`);
         }
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(tool, null, 2) }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error describing tool: ${err.message}` }],
-          isError: true
-        };
       }
-    }
-  );
-  mcpServer.registerTool(
-    "call_mcp_tool",
-    {
-      title: "Call MCP Tool",
-      description: "Call a tool on the connected MCP server. Responses go through the interceptor: images/audio are saved to disk, timeouts are enforced, and oversized text is truncated.",
-      inputSchema: {
-        name: z.string().describe("Name of the tool to call"),
-        arguments: z.record(z.unknown()).optional().describe("Arguments to pass to the tool (as a JSON object)"),
-        timeout_ms: z.number().optional().describe("Timeout for this specific call in milliseconds (overrides default)")
+      if (requested.includes("prompts") && caps.prompts) {
+        try {
+          const result = await target.listPrompts();
+          let prompts = result.prompts;
+          if (name) {
+            prompts = prompts.filter((p) => p.name === name);
+            if (prompts.length === 0) {
+              const available = result.prompts.map((p) => p.name).join(", ");
+              sections.push(
+                "--- Prompts ---",
+                `Prompt "${name}" not found.
+Available: ${available}`
+              );
+            } else {
+              sections.push("--- Prompts ---", JSON.stringify(prompts[0], null, 2));
+            }
+          } else {
+            sections.push("--- Prompts ---", JSON.stringify(prompts, null, 2));
+          }
+        } catch (err) {
+          sections.push("--- Prompts ---", `Error: ${err.message}`);
+        }
       }
-    },
-    async ({ name, arguments: toolArgs, timeout_ms }) => {
-      if (!target?.connected) {
+      if (sections.length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: "No target server connected. Use connect_to_mcp first."
+              text: "No matching primitives found. The server may not support the requested types."
             }
-          ],
-          isError: true
-        };
-      }
-      try {
-        const result = await interceptor.callTool(
-          target,
-          name,
-          toolArgs ?? {},
-          timeout_ms
-        );
-        return result;
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error: ${err.message}` }],
-          isError: true
+          ]
         };
       }
+      return {
+        content: [{ type: "text", text: sections.join("\n") }]
+      };
     }
   );
   mcpServer.registerTool(
-    "list_mcp_resources",
+    "list_available_mcp_servers",
     {
-      title: "List MCP Resources",
-      description: "List all resources exposed by the connected MCP server."
+      title: "List Available MCP Servers",
+      description: "Scans common configuration files (VS Code, Claude Desktop, Cursor, etc.) and returns a list of local MCP servers that the user has configured on their machine. This is useful for discovering what other servers are available to connect to."
     },
     async () => {
-      if (!target?.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No target server connected. Use connect_to_mcp first."
-            }
-          ],
-          isError: true
-        };
-      }
       try {
-        const result = await target.listResources();
-        return {
-          content: [{ type: "text", text: JSON.stringify(result.resources, null, 2) }]
-        };
+        const servers = await discoverServers();
+        if (servers.length === 0) {
+          return {
+            content: [{ type: "text", text: "No configured MCP servers discovered in common locations." }]
+          };
+        }
+        const lines = ["Discovered the following MCP server configurations:"];
+        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 list = Array.from(uniqueServers.values()).map((s) => ({
+          name: s.name,
+          source: s.source,
+          command: s.config.command,
+          args: s.config.args || []
+        }));
+        lines.push(JSON.stringify(list, null, 2));
+        return { content: [{ type: "text", text: lines.join("\n\n") }] };
       } catch (err) {
         return {
-          content: [{ type: "text", text: `Error listing resources: ${err.message}` }],
+          content: [{ type: "text", text: `Error discovering servers: ${err.message}` }],
           isError: true
         };
       }
     }
   );
   mcpServer.registerTool(
-    "read_mcp_resource",
+    "call_mcp_primitive",
     {
-      title: "Read MCP Resource",
-      description: "Read a specific resource by URI from the connected MCP server.",
+      title: "Call MCP Primitive",
+      description: "Call a tool, read a resource, or get a prompt on a target MCP server. If not connected, provide command/args and a connection will be opened automatically. Use disconnect_after to tear down the connection when done, or leave it open (default) for subsequent calls.",
       inputSchema: {
-        uri: z.string().describe("URI of the resource to read (e.g. 'docs://readme')")
+        // What to call
+        type: z.enum(["tool", "resource", "prompt"]).describe("The MCP primitive type to invoke"),
+        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."
+        ),
+        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')")
       }
     },
-    async ({ uri }) => {
-      if (!target?.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No target server connected. Use connect_to_mcp first."
-            }
-          ],
-          isError: true
-        };
-      }
+    async ({
+      type: primitiveType,
+      name,
+      arguments: callArgs,
+      command,
+      args,
+      env,
+      disconnect_after,
+      timeout_ms
+    }) => {
       try {
-        const result = await target.readResource({ uri });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result.contents, null, 2) }]
-        };
+        const connectError = await ensureConnected(command, args, env);
+        if (connectError) {
+          return {
+            content: [{ type: "text", text: connectError }],
+            isError: true
+          };
+        }
       } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error reading resource: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  mcpServer.registerTool(
-    "list_mcp_prompts",
-    {
-      title: "List MCP Prompts",
-      description: "List all prompts exposed by the connected MCP server."
-    },
-    async () => {
-      if (!target?.connected) {
         return {
           content: [
             {
               type: "text",
-              text: "No target server connected. Use connect_to_mcp first."
+              text: `Failed to auto-connect: ${err.message}
+
+Check that the command is correct and the server starts without errors.`
             }
           ],
           isError: true
         };
       }
+      let result;
       try {
-        const result = await target.listPrompts();
-        return {
-          content: [{ type: "text", text: JSON.stringify(result.prompts, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error listing prompts: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  mcpServer.registerTool(
-    "get_mcp_prompt",
-    {
-      title: "Get MCP Prompt",
-      description: "Get a specific prompt by name from the connected MCP server.",
-      inputSchema: {
-        name: z.string().describe("Name of the prompt"),
-        arguments: z.record(z.string()).optional().describe("Arguments to pass to the prompt")
-      }
-    },
-    async ({ name, arguments: promptArgs }) => {
-      if (!target?.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No target server connected. Use connect_to_mcp first."
+        switch (primitiveType) {
+          case "tool": {
+            try {
+              const { tools } = await target.listTools();
+              const toolNames = tools.map((t) => t.name);
+              const matchedTool = tools.find((t) => t.name === name);
+              if (!matchedTool) {
+                const suggestion = suggestCommand(name, toolNames);
+                const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Tool "${name}" not found.${hint}
+Available tools: ${toolNames.join(", ")}`
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              const schema = matchedTool.inputSchema;
+              const requiredProps = schema?.required ?? [];
+              const providedKeys = Object.keys(callArgs ?? {});
+              const missingProps = requiredProps.filter((p) => !providedKeys.includes(p));
+              if (missingProps.length > 0) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Tool "${name}" requires: ${missingProps.join(", ")}. Received: ${JSON.stringify(callArgs ?? {})}`
+                    }
+                  ],
+                  isError: true
+                };
+              }
+            } catch {
             }
-          ],
-          isError: true
-        };
-      }
-      try {
-        const result = await target.getPrompt({
-          name,
-          arguments: promptArgs ?? {}
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result.messages, null, 2) }]
-        };
+            const startMs = Date.now();
+            result = await interceptor.callTool(
+              target,
+              name,
+              callArgs ?? {},
+              timeout_ms
+            );
+            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)`;
+              }
+            }
+            break;
+          }
+          case "resource": {
+            const resourceResult = await target.readResource({ uri: name });
+            result = {
+              content: [
+                { type: "text", text: JSON.stringify(resourceResult.contents, null, 2) }
+              ]
+            };
+            break;
+          }
+          case "prompt": {
+            const promptResult = await target.getPrompt({
+              name,
+              arguments: callArgs ?? {}
+            });
+            result = {
+              content: [
+                { type: "text", text: JSON.stringify(promptResult.messages, null, 2) }
+              ]
+            };
+            break;
+          }
+        }
       } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error getting prompt: ${err.message}` }],
+        result = {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
           isError: true
         };
       }
+      if (disconnect_after && target) {
+        previousSnapshot = await takeSnapshot();
+        await target.close();
+        target = null;
+      }
+      return result;
     }
   );
   mcpServer.registerTool(
@@ -1273,72 +3210,99 @@ Available tools: ${available}` }
   };
   await mcpServer.connect(transport);
   process.stderr.write("[server] run-mcp test harness running on stdio.\n");
-  process.stderr.write("[server] Waiting for connect_to_mcp call...\n");
+  process.stderr.write("[server] Waiting for connect_to_mcp or call_mcp_primitive call...\n");
 }
 
 // src/index.ts
-program.name("run-mcp").enablePositionalOptions().description(
-  "A smart interactive REPL and live test harness for MCP servers.\n\nOperates in two modes:\n  repl    - Human-friendly CLI for testing MCP servers interactively\n  server  - MCP server that lets AI agents dynamically test local MCP servers"
-).version("1.3.1").addHelpText(
-  "after",
-  `
-Examples:
-  $ run-mcp repl node my-server.js               # Interactive testing (human)
-  $ run-mcp repl node my-server.js -s test.txt    # Run a script
-  $ run-mcp server                                # Test harness (agent)
-  $ run-mcp repl npx -y some-mcp-server           # Test an npx server
-
-Run 'run-mcp <command> --help' for detailed options.`
-);
-if (process.argv.length <= 2) {
-  program.outputHelp();
-  process.exit(0);
-}
-program.command("repl").description("Start an interactive REPL session with a target MCP server").passThroughOptions().allowUnknownOption().argument("<target_command...>", "Command to spawn the target MCP server").option("-s, --script <file>", "Read commands from a file instead of stdin").option("-o, --out-dir <path>", "Directory to save intercepted images").addHelpText(
-  "after",
-  `
-Examples:
-  $ run-mcp repl node my-server.js
-  $ run-mcp repl node my-server.js --script verify.txt
-  $ run-mcp repl node my-server.js --out-dir ./screenshots
-
-REPL Commands (once connected):
-  tools/list                          List all available tools
-  tools/describe <name>               Show a tool's input schema
-  tools/call <name> <json> [opts]     Call a tool with JSON arguments
-  status                              Show target server status
-  help                                Show all commands`
-).action(async (targetCommand, opts) => {
-  await startRepl(targetCommand, opts);
-});
-program.command("server").description("Start as an MCP server that lets AI agents dynamically test local MCP servers").option("-o, --out-dir <path>", "Directory to save intercepted images and audio").option("-t, --timeout <ms>", "Default tool call timeout in milliseconds (default: 300000)").option("--max-text <chars>", "Max text response length before truncation (default: 50000)").addHelpText(
+program.name("run-mcp").description("A smart interactive REPL and live test harness for MCP servers").version("1.4.0").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(
+  "-t, --timeout <ms>",
+  "Default tool call timeout in milliseconds (default: 300000) (Agent Mode only)"
+).option(
+  "--max-text <chars>",
+  "Max text response length before truncation (default: 50000) (Agent Mode only)"
+).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 server
-  $ run-mcp server --out-dir ./test-output
-  $ run-mcp server --timeout 120000
+  $ 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 --out-dir ./test-output               # Agent mode with options
+  $ run-mcp --out-dir ./screenshots node srv.js   # REPL mode with options
 
-Add to your MCP client configuration:
+Agent Mode Configuration (mcp.json):
   {
     "mcpServers": {
       "run-mcp": {
         "command": "npx",
-        "args": ["-y", "run-mcp", "server"]
+        "args": ["-y", "run-mcp"]
       }
     }
   }
 
-Then use these tools from your agent:
-  connect_to_mcp      \u2192 Spawn and connect to a local MCP server
-  list_mcp_tools      \u2192 List tools on the connected server
-  call_mcp_tool       \u2192 Call a tool (with interception)
-  disconnect_from_mcp \u2192 Tear down and reconnect after changes`
-).action(async (opts) => {
-  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
-  });
-});
+Agent Mode Tools:
+  connect_to_mcp       \u2192 Spawn and connect (use include to get tools/resources/prompts)
+  call_mcp_primitive   \u2192 Call a tool, read a resource, or get a prompt (auto-connects)
+  list_mcp_primitives  \u2192 List tools, resources, and/or prompts
+  disconnect_from_mcp  \u2192 Tear down and reconnect after changes
+  mcp_server_status    \u2192 Check connection status
+  get_mcp_server_stderr \u2192 View target server stderr output
+
+REPL Mode Commands (once connected):
+  tools/list                          List all available tools
+  tools/describe <name>               Show a tool's input schema
+  tools/call <name> [json] [opts]     Call a tool (interactive if no json)
+  tools/scaffold <name>               Generate argument template for a tool
+  resources/list                      List all available resources
+  resources/read <uri>                Read a resource by URI
+  resources/templates                 List resource templates
+  resources/subscribe <uri>           Subscribe to resource changes
+  resources/unsubscribe <uri>         Unsubscribe from resource changes
+  prompts/list                        List all available prompts
+  prompts/get <name> [json_args]      Get a prompt with arguments
+  ping                                Verify connection, show round-trip time
+  log-level <level>                   Set server logging verbosity
+  history [count|clear]               Show request/response history
+  notifications [count|clear]         Show server notifications
+  roots/list                          Show configured client roots
+  roots/add <uri> [name]              Add a root directory
+  roots/remove <uri>                  Remove a root directory
+  !! / last                           Re-run the last command
+  reconnect                           Disconnect and reconnect
+  timing                              Show tool call performance stats
+  status                              Show target server status
+
+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 });
+    } 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
+        });
+      } else {
+        const selected = await pickDiscoveredServer();
+        if (!selected) {
+          console.log("Run 'run-mcp --help' to see manual usage instructions.");
+          return;
+        }
+        if (selected.config.env) {
+          Object.assign(process.env, selected.config.env);
+        }
+        await startRepl([selected.config.command, ...selected.config.args || []], {
+          script: opts.script,
+          outDir: opts.outDir
+        });
+      }
+    }
+  }
+);
 program.parse();