chainlesschain 0.162.37 → 0.162.38

package/src/commands/mcp.js

@@ -38,6 +38,49 @@ function getClient() {
   return mcpClient;
 }
 
+/**
+ * Connect MCP server(s) for a one-shot query (resources / prompts). Connects
+ * the named server, or every registered server when `serverName` is omitted.
+ * Returns `{ client, connected }`; the caller must `await shutdown()`.
+ */
+async function connectForQuery(program, serverName) {
+  const ctx = await bootstrap({ verbose: program.opts().verbose });
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  const config = new MCPServerConfig(db);
+  let rows;
+  if (serverName) {
+    const row = config.get(serverName);
+    if (!row) {
+      logger.error(
+        `Server "${serverName}" not configured. Use 'mcp add' first.`,
+      );
+      await shutdown();
+      process.exit(1);
+    }
+    rows = [row];
+  } else {
+    rows = config.list();
+  }
+  const client = new MCPClient();
+  const connected = [];
+  for (const row of rows) {
+    if (!row) continue;
+    try {
+      await client.connect(row.name, row);
+      connected.push(row.name);
+    } catch (err) {
+      logger.log(
+        chalk.yellow(`  Failed to connect "${row.name}": ${err.message}`),
+      );
+    }
+  }
+  return { client, connected };
+}
+
 // Phase 3 (Hosted MCP Policy): resolve runtime mode from --mode > env > local.
 function resolveMode(options) {
   return (
@@ -68,10 +111,20 @@ export function registerMcpCommand(program) {
   // mcp login — OAuth 2.0 (Auth Code + PKCE) for a remote MCP server.
   mcp
     .command("login <url>")
-    .description("Authorize a remote MCP server via OAuth (opens a browser); stores the token")
+    .description(
+      "Authorize a remote MCP server via OAuth (opens a browser); stores the token",
+    )
     .option("--scope <scope>", "OAuth scope(s) to request")
-    .option("--client-id <id>", "Use a pre-registered client_id instead of dynamic registration")
-    .option("--port <n>", "Localhost callback port", (v) => parseInt(v, 10), 53682)
+    .option(
+      "--client-id <id>",
+      "Use a pre-registered client_id instead of dynamic registration",
+    )
+    .option(
+      "--port <n>",
+      "Localhost callback port",
+      (v) => parseInt(v, 10),
+      53682,
+    )
     .option("--no-open", "Print the authorize URL instead of opening a browser")
     .action(async (url, options) => {
       try {
@@ -109,7 +162,8 @@ export function registerMcpCommand(program) {
     .description("Delete the stored OAuth token for a remote MCP server")
     .action(async (url) => {
       try {
-        const { deleteStoredToken, serverKey } = await import("../lib/mcp-oauth.js");
+        const { deleteStoredToken, serverKey } =
+          await import("../lib/mcp-oauth.js");
         const ok = deleteStoredToken(url);
         logger.log(
           ok
@@ -129,7 +183,8 @@ export function registerMcpCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
-        const { loadTokenStore, isTokenExpired } = await import("../lib/mcp-oauth.js");
+        const { loadTokenStore, isTokenExpired } =
+          await import("../lib/mcp-oauth.js");
         const store = loadTokenStore();
         const rows = Object.values(store).map((r) => ({
           server: r.server,
@@ -142,7 +197,9 @@ export function registerMcpCommand(program) {
           return;
         }
         if (rows.length === 0) {
-          logger.log(chalk.gray("No MCP OAuth tokens. Run: cc mcp login <url>"));
+          logger.log(
+            chalk.gray("No MCP OAuth tokens. Run: cc mcp login <url>"),
+          );
           return;
         }
         for (const r of rows) {
@@ -566,6 +623,179 @@ export function registerMcpCommand(program) {
       }
     });
 
+  // mcp resources — list resources exposed by configured servers
+  mcp
+    .command("resources")
+    .description("List resources exposed by MCP servers")
+    .option("-s, --server <name>", "Filter by / connect only this server")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        const resources = client.listResources(options.server);
+        if (options.json) {
+          console.log(JSON.stringify(resources, null, 2));
+        } else if (resources.length === 0) {
+          logger.info("No resources available.");
+        } else {
+          logger.log(chalk.bold(`MCP Resources (${resources.length}):\n`));
+          for (const r of resources) {
+            logger.log(`  ${chalk.cyan(r.uri)} ${chalk.gray(`[${r.server}]`)}`);
+            if (r.name) logger.log(`    ${chalk.gray(r.name)}`);
+            if (r.description) logger.log(`    ${chalk.gray(r.description)}`);
+          }
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp read-resource — read a resource's contents by URI
+  mcp
+    .command("read-resource")
+    .description("Read an MCP resource by URI")
+    .argument("<uri>", "Resource URI")
+    .option("-s, --server <name>", "Server that owns the resource")
+    .option("--json", "Output as JSON")
+    .action(async (uri, options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        let server = options.server;
+        if (!server) {
+          const match = client.listResources().find((r) => r.uri === uri);
+          if (!match) {
+            logger.error(
+              `Resource "${uri}" not found. Run 'mcp resources' to list URIs.`,
+            );
+            await client.disconnectAll();
+            await shutdown();
+            process.exit(1);
+          }
+          server = match.server;
+        }
+        const result = await client.readResource(server, uri);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (Array.isArray(result?.contents)) {
+          for (const c of result.contents) {
+            if (typeof c.text === "string") {
+              logger.log(c.text);
+            } else if (c.blob) {
+              logger.log(
+                chalk.gray(
+                  `[Binary: ${c.mimeType || "application/octet-stream"}]`,
+                ),
+              );
+            } else {
+              logger.log(JSON.stringify(c, null, 2));
+            }
+          }
+        } else {
+          logger.log(JSON.stringify(result, null, 2));
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Read failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp prompts — list prompts (server-provided slash commands)
+  mcp
+    .command("prompts")
+    .description("List prompts exposed by MCP servers")
+    .option("-s, --server <name>", "Filter by / connect only this server")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        const prompts = client.listPrompts(options.server);
+        if (options.json) {
+          console.log(JSON.stringify(prompts, null, 2));
+        } else if (prompts.length === 0) {
+          logger.info("No prompts available.");
+        } else {
+          logger.log(chalk.bold(`MCP Prompts (${prompts.length}):\n`));
+          for (const p of prompts) {
+            logger.log(
+              `  ${chalk.cyan(`/mcp__${p.server}__${p.name}`)} ${chalk.gray(`[${p.server}]`)}`,
+            );
+            if (p.description) logger.log(`    ${chalk.gray(p.description)}`);
+            if (Array.isArray(p.arguments) && p.arguments.length > 0) {
+              const argNames = p.arguments
+                .map((a) => (a.required ? `${a.name}*` : a.name))
+                .join(", ");
+              logger.log(`    ${chalk.gray(`args: ${argNames}`)}`);
+            }
+          }
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp get-prompt — fetch a rendered prompt by name
+  mcp
+    .command("get-prompt")
+    .description("Fetch a rendered MCP prompt by name")
+    .argument("<name>", "Prompt name")
+    .option("-s, --server <name>", "Server that owns the prompt")
+    .option("-a, --args <json>", "Prompt arguments as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        let server = options.server;
+        if (!server) {
+          const match = client.listPrompts().find((p) => p.name === name);
+          if (!match) {
+            logger.error(
+              `Prompt "${name}" not found. Run 'mcp prompts' to list prompts.`,
+            );
+            await client.disconnectAll();
+            await shutdown();
+            process.exit(1);
+          }
+          server = match.server;
+        }
+        const args = options.args ? JSON.parse(options.args) : {};
+        const result = await client.getPrompt(server, name, args);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          if (result?.description) {
+            logger.log(chalk.gray(result.description) + "\n");
+          }
+          for (const msg of result?.messages || []) {
+            const blocks = Array.isArray(msg.content)
+              ? msg.content
+              : [msg.content];
+            for (const b of blocks) {
+              if (b && b.type === "text") {
+                logger.log(`${chalk.gray(`[${msg.role}]`)} ${b.text}`);
+              } else {
+                logger.log(
+                  `${chalk.gray(`[${msg.role}]`)} ${JSON.stringify(b)}`,
+                );
+              }
+            }
+          }
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Get prompt failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // mcp scaffold — generate a boilerplate MCP server project
   mcp
     .command("scaffold <name>")

package/src/harness/mcp-client.js

@@ -156,7 +156,7 @@ export class MCPClient extends EventEmitter {
       // Initialize MCP protocol
       const initResult = await this._sendRequest(name, "initialize", {
         protocolVersion: "2024-11-05",
-        capabilities: { tools: {}, resources: {} },
+        capabilities: { tools: {}, resources: {}, prompts: {} },
         clientInfo: { name: "chainlesschain-cli", version: "0.37.9" },
       });
 
@@ -187,12 +187,21 @@ export class MCPClient extends EventEmitter {
         // Server may not support resources
       }
 
+      // Fetch available prompts (server-provided slash commands)
+      try {
+        const promptsResult = await this._sendRequest(name, "prompts/list", {});
+        entry.prompts = promptsResult?.prompts || [];
+      } catch {
+        // Server may not support prompts
+      }
+
       this.emit("server-connected", { name, tools: entry.tools.length });
       return {
         name,
         state: entry.state,
         tools: entry.tools,
         resources: entry.resources,
+        prompts: entry.prompts,
         serverInfo: entry.serverInfo,
       };
     } catch (err) {
@@ -250,6 +259,7 @@ export class MCPClient extends EventEmitter {
         state: entry.state,
         tools: entry.tools.length,
         resources: entry.resources.length,
+        prompts: (entry.prompts || []).length,
         serverInfo: entry.serverInfo || {},
       });
     }
@@ -296,6 +306,26 @@ export class MCPClient extends EventEmitter {
     return result;
   }
 
+  /**
+   * List resources from a specific server or all servers. Each resource is
+   * annotated with its owning `server` (mirrors `listTools`).
+   */
+  listResources(serverName) {
+    if (serverName) {
+      const entry = this.servers.get(serverName);
+      if (!entry) throw new Error(`Server "${serverName}" not found`);
+      return (entry.resources || []).map((r) => ({ ...r, server: serverName }));
+    }
+
+    const all = [];
+    for (const [name, entry] of this.servers) {
+      for (const r of entry.resources || []) {
+        all.push({ ...r, server: name });
+      }
+    }
+    return all;
+  }
+
   /**
    * Read a resource from a server.
    */
@@ -309,6 +339,45 @@ export class MCPClient extends EventEmitter {
     return result;
   }
 
+  /**
+   * List prompts from a specific server or all servers. Each prompt is
+   * annotated with its owning `server` (mirrors `listTools`).
+   */
+  listPrompts(serverName) {
+    if (serverName) {
+      const entry = this.servers.get(serverName);
+      if (!entry) throw new Error(`Server "${serverName}" not found`);
+      return (entry.prompts || []).map((p) => ({ ...p, server: serverName }));
+    }
+
+    const all = [];
+    for (const [name, entry] of this.servers) {
+      for (const p of entry.prompts || []) {
+        all.push({ ...p, server: name });
+      }
+    }
+    return all;
+  }
+
+  /**
+   * Fetch a rendered prompt (`prompts/get`) from a server. `args` is a map of
+   * the prompt's named arguments to string values. Returns the server's result
+   * `{ description?, messages: [...] }`.
+   */
+  async getPrompt(serverName, promptName, args = {}) {
+    const entry = this.servers.get(serverName);
+    if (!entry) throw new Error(`Server "${serverName}" not found`);
+    if (entry.state !== ServerState.CONNECTED) {
+      throw new Error(`Server "${serverName}" is not connected`);
+    }
+
+    const result = await this._sendRequest(serverName, "prompts/get", {
+      name: promptName,
+      arguments: args || {},
+    });
+    return result;
+  }
+
   // ─── Internal JSON-RPC transport ──────────────────────────────
 
   _sendRequest(serverName, method, params) {

package/src/lib/settings-hooks.cjs

@@ -37,6 +37,7 @@ const HOOK_EVENTS = Object.freeze([
   "PostToolUse",
   "UserPromptSubmit",
   "Stop",
+  "SubagentStop",
   "SessionStart",
   "SessionEnd",
   "PreCompact",

package/src/repl/agent-repl.js

@@ -74,6 +74,7 @@ import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import { makeFallbackChatFn } from "../runtime/fallback-model.js";
 import { resolveSlashMacro } from "./slash-macro.js";
+import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -129,7 +130,8 @@ async function _persistAlwaysAllow(tool, args) {
       scope: "local",
     });
     if (!_permissionRules) _permissionRules = { allow: [], ask: [], deny: [] };
-    if (!_permissionRules.allow.includes(rule)) _permissionRules.allow.push(rule);
+    if (!_permissionRules.allow.includes(rule))
+      _permissionRules.allow.push(rule);
     return { rule, file };
   } catch (err) {
     process.stderr.write(`  always-allow persist failed: ${err.message}\n`);
@@ -504,9 +506,8 @@ export async function startAgentRepl(options = {}) {
   // settings.json SessionStart hooks → inject session context (observe-only).
   if (_settingsHooks) {
     try {
-      const { runSessionStartHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runSessionStartHooks } =
+        await import("../lib/settings-hook-events.cjs");
       const ctx = runSessionStartHooks(_settingsHooks, {
         source: "startup",
         cwd: process.cwd(),
@@ -805,7 +806,8 @@ export async function startAgentRepl(options = {}) {
     if (_statusLineEnabled && _renderStatus) {
       const line = _renderStatus();
       // Built-in line is dimmed; a custom command may carry its own ANSI.
-      if (line) process.stdout.write((_customStatus ? line : chalk.dim(line)) + "\n");
+      if (line)
+        process.stdout.write((_customStatus ? line : chalk.dim(line)) + "\n");
     }
     rl.setPrompt(getPrompt());
     rl.prompt();
@@ -1024,15 +1026,16 @@ export async function startAgentRepl(options = {}) {
         logger.info("Status line: on");
       } else {
         // bare / "show" → report state + a one-off render
-        const line = _statusLineEnabled && _renderStatus ? _renderStatus() : null;
+        const line =
+          _statusLineEnabled && _renderStatus ? _renderStatus() : null;
         if (line) {
-          logger.info(
-            `Status line: ${_customStatus ? line : chalk.dim(line)}`,
-          );
+          logger.info(`Status line: ${_customStatus ? line : chalk.dim(line)}`);
         } else {
           logger.info(
             `Status line: ${_statusLineEnabled ? "on (no content yet)" : "off"}` +
-              (_statusLineEnabled ? "" : ` — enable with ${chalk.cyan("/statusline on")}`),
+              (_statusLineEnabled
+                ? ""
+                : ` — enable with ${chalk.cyan("/statusline on")}`),
           );
         }
         if (_customStatus) {
@@ -1046,9 +1049,8 @@ export async function startAgentRepl(options = {}) {
     if (trimmed === "/output-style" || trimmed.startsWith("/output-style ")) {
       const arg = trimmed.slice("/output-style".length).trim();
       try {
-        const { discoverOutputStyles, getOutputStyle } = await import(
-          "../lib/output-styles.js"
-        );
+        const { discoverOutputStyles, getOutputStyle } =
+          await import("../lib/output-styles.js");
         if (!arg) {
           logger.log(chalk.bold("Output styles:"));
           for (const s of discoverOutputStyles(process.cwd())) {
@@ -1801,15 +1803,47 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/mcp` — overview of connected MCP servers' resources + prompts.
+    if (trimmed === "/mcp" || trimmed === "/mcp ") {
+      const mcpClient = _adhocMcp?.mcpClient || _bundleMcpClient;
+      logger.log(renderMcpSurface(mcpClient));
+      prompt();
+      return;
+    }
+
     // User-defined slash-command macros (.claude/commands/*.md), Claude-Code
     // parity. resolveSlashMacro maps a leading /name to a command macro and
     // expands its template; a non-match returns the line unchanged so a literal
     // prompt like "/etc/hosts" still reaches the LLM. Wire is unit-tested.
     let promptText = trimmed;
+
+    // MCP server-provided prompts (Claude-Code parity): `/mcp__<server>__<name>
+    // [json-args]` fetches a rendered prompt template from the connected MCP
+    // server and uses its text as this turn's input. Falls through unchanged
+    // when the line isn't an MCP prompt command.
+    if (promptText.startsWith("/mcp__")) {
+      try {
+        const expanded = await expandMcpPrompt(
+          promptText,
+          _adhocMcp?.mcpClient || _bundleMcpClient,
+        );
+        if (expanded != null) {
+          promptText = expanded;
+          logger.log(chalk.gray(`[mcp] prompt expanded`));
+        }
+      } catch (err) {
+        logger.info(
+          chalk.yellow(`[mcp] prompt expansion failed: ${err.message}`),
+        );
+        prompt();
+        return;
+      }
+    }
     try {
       const macro = await resolveSlashMacro(trimmed, { cwd: process.cwd() });
       if (macro.matched) {
-        for (const w of macro.warnings) logger.info(chalk.yellow(`[@ref] ${w}`));
+        for (const w of macro.warnings)
+          logger.info(chalk.yellow(`[@ref] ${w}`));
         promptText = macro.promptText;
         logger.log(
           chalk.gray(`[/${macro.name}] macro expanded (${macro.scope})`),
@@ -1864,9 +1898,8 @@ export async function startAgentRepl(options = {}) {
     // is observe-only). block → abort the turn; context → inject before the turn.
     if (_settingsHooks) {
       try {
-        const { runUserPromptSubmitHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runUserPromptSubmitHooks } =
+          await import("../lib/settings-hook-events.cjs");
         const ups = runUserPromptSubmitHooks(_settingsHooks, {
           prompt: userContent,
           cwd: process.cwd(),
@@ -2136,9 +2169,8 @@ export async function startAgentRepl(options = {}) {
     // settings.json SessionEnd hooks (observe-only) when the REPL exits.
     if (_settingsHooks) {
       try {
-        const { runObserveHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runObserveHooks } =
+          await import("../lib/settings-hook-events.cjs");
         runObserveHooks(
           _settingsHooks,
           "SessionEnd",

package/src/repl/mcp-prompt.js

@@ -0,0 +1,122 @@
+/**
+ * MCP prompt + resource surfacing for the agent REPL (Claude-Code parity).
+ *
+ * MCP servers can expose "prompts" — server-defined, parameterized prompt
+ * templates — which Claude Code surfaces as slash commands of the form
+ * `/mcp__<server>__<prompt>`. This module is the pure, unit-testable core:
+ * it parses such a command, fetches the rendered prompt from the connected
+ * MCP client, and flattens it into plain text to use as the user's turn.
+ *
+ * It also renders a `/mcp` overview of every connected server's resources and
+ * prompts. The REPL (agent-repl.js) wires these in; all the logic lives here so
+ * it can be tested without spinning up a readline session.
+ */
+
+/**
+ * Parse a `/mcp__<server>__<prompt> [args]` line. Returns `{ server, name,
+ * args }` or `null` when the line is not an MCP prompt invocation.
+ *
+ * `args` is parsed from a trailing JSON object when present; a non-JSON tail is
+ * passed as `{ input: "<tail>" }` so simple one-arg prompts stay ergonomic.
+ */
+export function parseMcpPromptCommand(line) {
+  const trimmed = (line || "").trim();
+  if (!trimmed.startsWith("/mcp__")) return null;
+
+  const sp = trimmed.search(/\s/);
+  const token = sp === -1 ? trimmed : trimmed.slice(0, sp);
+  const rest = sp === -1 ? "" : trimmed.slice(sp + 1).trim();
+
+  const full = token.slice(1); // drop leading "/"
+  const parts = full.split("__"); // ["mcp", "<server>", "<prompt...>"]
+  if (parts.length < 3 || parts[0] !== "mcp") return null;
+  const server = parts[1];
+  const name = parts.slice(2).join("__");
+  if (!server || !name) return null;
+
+  let args = {};
+  if (rest) {
+    try {
+      const parsed = JSON.parse(rest);
+      args =
+        parsed && typeof parsed === "object" && !Array.isArray(parsed)
+          ? parsed
+          : { input: rest };
+    } catch {
+      args = { input: rest };
+    }
+  }
+  return { server, name, args };
+}
+
+/**
+ * Flatten an MCP `prompts/get` result (`{ messages: [...] }`) into plain text.
+ * Handles text blocks and embedded text resources; ignores binary blocks.
+ */
+export function renderPromptMessages(result) {
+  const messages = Array.isArray(result?.messages) ? result.messages : [];
+  const out = [];
+  for (const msg of messages) {
+    const blocks = Array.isArray(msg?.content) ? msg.content : [msg?.content];
+    for (const b of blocks) {
+      if (!b) continue;
+      if (b.type === "text" && typeof b.text === "string") {
+        out.push(b.text);
+      } else if (
+        b.type === "resource" &&
+        b.resource &&
+        typeof b.resource.text === "string"
+      ) {
+        out.push(b.resource.text);
+      }
+    }
+  }
+  return out.join("\n\n");
+}
+
+/**
+ * Expand a `/mcp__server__prompt` line into prompt text by calling the MCP
+ * client. Returns the rendered text, or `null` when the line is not an MCP
+ * prompt command. Throws if the underlying `getPrompt` fails (caller decides
+ * whether to surface or swallow).
+ */
+export async function expandMcpPrompt(line, mcpClient) {
+  const cmd = parseMcpPromptCommand(line);
+  if (!cmd) return null;
+  if (!mcpClient || typeof mcpClient.getPrompt !== "function") {
+    throw new Error("No MCP servers are connected this session.");
+  }
+  const result = await mcpClient.getPrompt(cmd.server, cmd.name, cmd.args);
+  return renderPromptMessages(result);
+}
+
+/**
+ * Render a human overview of all connected MCP resources + prompts for `/mcp`.
+ */
+export function renderMcpSurface(mcpClient) {
+  if (!mcpClient) return "No MCP servers are connected this session.";
+  const resources =
+    typeof mcpClient.listResources === "function"
+      ? mcpClient.listResources()
+      : [];
+  const prompts =
+    typeof mcpClient.listPrompts === "function" ? mcpClient.listPrompts() : [];
+
+  const lines = [];
+  lines.push(`MCP resources (${resources.length}):`);
+  for (const r of resources) {
+    lines.push(`  ${r.uri} [${r.server}]${r.name ? " — " + r.name : ""}`);
+  }
+  lines.push("");
+  lines.push(`MCP prompts (${prompts.length}):`);
+  for (const p of prompts) {
+    lines.push(
+      `  /mcp__${p.server}__${p.name}${p.description ? " — " + p.description : ""}`,
+    );
+  }
+  if (resources.length === 0 && prompts.length === 0) {
+    lines.push("");
+    lines.push("(connected servers expose no resources or prompts)");
+  }
+  return lines.join("\n");
+}