rovecode 0.3.2

package/src/mcp/status.ts

@@ -0,0 +1,67 @@
+/** MCP status text (port #57). Cache-only by default — SHOWING status never connects
+ *  anything, so an idle session stays idle; `connectAndPrefetch` forces the connect plus
+ *  one listing per kind so the counts are real. Pattern (Apache-2.0, pattern only):
+ *  gemini-cli's /mcp per-server status rows.
+ *  Rovecode: a pure module with no TUI adapter — rovecode's `/mcp` is the MCP market
+ *  (tui/mcp-cmd.ts), so the verb a row points the reader at (`connectVerb`) and the
+ *  empty-state hint are the CALLER's words, passed in; the defaults are what a
+ *  `/mcp connect` verb would read once a surface adds one. Nothing here is wired yet. */
+
+import type { McpManager } from "./client.ts";
+import { depthFor } from "./prompts-resources.ts";
+
+const ERROR_CLIP = 80;
+
+/** One line, whitespace folded, hard-capped (error text from a server is unbounded). */
+export function clip(text: string, max = ERROR_CLIP): string {
+  const one = text.replace(/\s+/g, " ").trim();
+  return one.length <= max ? one : `${one.slice(0, max - 1)}…`;
+}
+
+/** The connect verb: connect every enabled server, then warm tools/prompts/resources.
+ *  Returns human notes (connect failures, per-server listing errors). */
+export async function connectAndPrefetch(manager: McpManager, signal?: AbortSignal): Promise<string[]> {
+  const res = await manager.connect();
+  const notes = res.failed.map((f) => `${f.name}: ${clip(f.error)}`);
+  notes.push(...(await depthFor(manager).prefetch(signal)));
+  return notes;
+}
+
+/** The surface's own words: the verb that connects + prefetches, and how a server gets configured. */
+export interface StatusHints {
+  /** what a not-yet-connected / not-yet-fetched row tells the reader to run (default `/mcp connect`) */
+  connectVerb: string;
+  /** how to add a server (default: the market's shell commands) */
+  addHint: string;
+}
+export const DEFAULT_STATUS_HINTS: StatusHints = { connectVerb: "/mcp connect", addHint: "rovecode mcp search <query> · rovecode mcp add <name>" };
+
+/** One row per configured server. `configPath` (mcpConfigPath(cwd)) feeds the empty-state hint. */
+export function formatMcpStatus(manager: McpManager | null, configPath: string, hints: StatusHints = DEFAULT_STATUS_HINTS): string {
+  if (!manager || manager.serverNames().length === 0) {
+    return `no MCP servers configured — ${hints.addHint} (project config: ${configPath}; a harvested .mcp.json is read too)`;
+  }
+  const depth = depthFor(manager);
+  const rows = manager.status();
+  const lines = rows.map((s) => {
+    const wire = s.wire === undefined || s.wire === "custom" ? s.transport : s.fellBack ? `${s.transport} → ${s.wire} fallback` : s.wire;
+    switch (s.state) {
+      case "disabled": return `${s.name}  disabled (${s.transport})`;
+      case "pending": return `${s.name}  not connected yet (${s.transport}) — ${hints.connectVerb}`;
+      case "failed": return `${s.name}  failed (${s.transport}): ${clip(s.error ?? "unknown error")}`;
+      default: {
+        const c = depth.counts(s.name);
+        const counts = s.tools === undefined && c.prompts === undefined && c.resources === undefined
+          ? `tools/prompts/resources not fetched yet — ${hints.connectVerb}`
+          : [
+              `tools ${s.tools ?? "not fetched"}`,
+              `prompts ${c.prompts ?? "not fetched"}`,
+              `resources ${c.resources ?? "not fetched"}${c.templates ? ` (+${c.templates} template${c.templates === 1 ? "" : "s"})` : ""}`,
+            ].join(" · ");
+        return `${s.name}  connected (${wire}) · ${counts}`;
+      }
+    }
+  });
+  const connected = rows.filter((s) => s.state === "connected").length;
+  return [`MCP servers: ${rows.length} configured, ${connected} connected`, ...lines].join("\n");
+}

package/src/mcp/tools.ts

@@ -0,0 +1,275 @@
+/** The lazy-disclosure seam (port #3 + #57): a handful of TINY house tools are
+ *  advertised to the model, regardless of how many MCP servers/tools exist.
+ *  mcp_list returns a compact one-line-per-tool index (schemas on demand via a
+ *  {schema:true} flag); mcp_call executes. Port #57 adds the same shape for
+ *  prompts (mcp_prompts / mcp_prompt) and resources (mcp_resources / mcp_read).
+ *  Full server schemas never enter the system prompt — that is the ~0
+ *  idle-token invariant (mcp.test.ts pins the COMBINED schema size). SDK-free at
+ *  load: the runtime requires this file at createRuntime. */
+
+import type { Tool, ToolContext, ToolOutput } from "../core/types.ts";
+import type { McpManager } from "./client.ts";
+import { message } from "./config.ts";
+import { depthFor, type McpPromptInfo, type McpResourceIndex } from "./prompts-resources.ts";
+
+const DESC_MAX = 60;
+const SCHEMA_MAX = 1_500;
+
+/** First line of a description, hard-capped for the index. */
+function compact(desc: string): string {
+  const line = (desc.split("\n", 1)[0] ?? "").trim();
+  return line.length <= DESC_MAX ? line : `${line.slice(0, DESC_MAX - 1)}…`;
+}
+
+function renderSchema(schema: object): string {
+  const rendered = JSON.stringify(schema);
+  return rendered.length > SCHEMA_MAX ? `${rendered.slice(0, SCHEMA_MAX)}…` : rendered;
+}
+
+/** A non-empty string argument, or undefined (tolerates non-object rawArgs). */
+function strArg(raw: unknown, key: string): string | undefined {
+  const v = (raw as Record<string, unknown> | null | undefined)?.[key];
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
+function notConnected(manager: McpManager, server: string): ToolOutput {
+  const connected = manager.connectedNames();
+  return { ok: false, output: `MCP server "${server}" is not connected. Connected: ${connected.length > 0 ? connected.join(", ") : "(none)"}` };
+}
+
+interface McpListArgs {
+  server?: string;
+  tool?: string;
+  schema?: boolean;
+}
+
+interface McpCallArgs {
+  server?: string;
+  tool?: string;
+  args?: unknown;
+}
+
+/** Build the house tools bound to a manager: [mcp_list, mcp_call, mcp_prompts, mcp_prompt, mcp_resources, mcp_read]. */
+export function createMcpTools(manager: McpManager): Tool[] {
+  const list: Tool = {
+    schema: {
+      name: "mcp_list",
+      description:
+        "List tools on connected MCP servers as 'server/tool — description'. " +
+        "With {server, tool, schema:true} returns that one tool's full JSON input schema.",
+      args: {
+        type: "object",
+        properties: {
+          server: { type: "string", description: "only list this server" },
+          tool: { type: "string", description: "tool name (for schema lookup)" },
+          schema: { type: "boolean", description: "return the full input schema for server+tool" },
+        },
+        additionalProperties: false,
+      },
+    },
+    kind: "read",
+    sequential: false,
+    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const a = (rawArgs ?? {}) as McpListArgs;
+      const server = typeof a.server === "string" && a.server.length > 0 ? a.server : undefined;
+      const tool = typeof a.tool === "string" && a.tool.length > 0 ? a.tool : undefined;
+
+      // schema mode: full JSON schema for exactly one tool, on demand
+      if (a.schema === true || tool !== undefined) {
+        if (server === undefined || tool === undefined) {
+          return { ok: false, output: "schema lookup needs both server and tool, e.g. {server:\"x\", tool:\"y\", schema:true}" };
+        }
+        const schema = await manager.toolSchema(server, tool, ctx.signal);
+        if (schema === undefined) {
+          return { ok: false, output: `no schema for "${tool}" on "${server}" (unknown tool or server not connected); run mcp_list first` };
+        }
+        return { ok: true, output: `input schema for ${server}/${tool}: ${renderSchema(schema)}`, data: schema };
+      }
+
+      // index mode: compact one-liners only
+      const tools = await manager.listTools(false, ctx.signal);
+      const filtered = server === undefined ? tools : tools.filter((t) => t.server === server);
+      if (filtered.length === 0) {
+        const connected = manager.connectedNames();
+        if (server !== undefined && !connected.includes(server)) {
+          return { ok: false, output: `MCP server "${server}" is not connected. Connected: ${connected.length > 0 ? connected.join(", ") : "(none)"}` };
+        }
+        return { ok: true, output: connected.length === 0 ? "no MCP servers connected" : "no tools advertised by connected MCP servers" };
+      }
+      const lines = filtered.map((t) => `${t.server}/${t.name} — ${compact(t.description)}`);
+      lines.push("", "call with mcp_call {server, tool, args}; arg schema via mcp_list {server, tool, schema:true}");
+      return { ok: true, output: lines.join("\n"), data: filtered };
+    },
+  };
+
+  const call: Tool = {
+    schema: {
+      name: "mcp_call",
+      description:
+        "Call a tool on a connected MCP server. Discover names with mcp_list; " +
+        "on argument errors the tool's input schema is included so you can retry.",
+      args: {
+        type: "object",
+        properties: {
+          server: { type: "string", description: "MCP server name" },
+          tool: { type: "string", description: "tool name on that server" },
+          args: { type: "object", description: "arguments matching the tool's input schema" },
+        },
+        required: ["server", "tool"],
+        additionalProperties: false,
+      },
+    },
+    kind: "custom", // policy maps this to action "tool.mcp_call" (prompt-gated by default)
+    interruptible: true,
+    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const a = (rawArgs ?? {}) as McpCallArgs;
+      const server = typeof a.server === "string" && a.server.length > 0 ? a.server : undefined;
+      const tool = typeof a.tool === "string" && a.tool.length > 0 ? a.tool : undefined;
+      if (server === undefined || tool === undefined) {
+        return { ok: false, output: 'mcp_call requires string "server" and "tool" (discover them with mcp_list)' };
+      }
+
+      const res = await manager.callTool(server, tool, a.args, ctx.signal, ctx.onUpdate);
+      if (res.ok) return { ok: true, output: res.output };
+
+      // validation-error path: attach the input schema (cache-hot after the call
+      // above) so the model can self-correct without a discovery round-trip.
+      let output = res.output;
+      if (!ctx.signal.aborted) {
+        const schema = await manager.toolSchema(server, tool, ctx.signal);
+        if (schema !== undefined) output += `\n\ninput schema for ${server}/${tool}: ${renderSchema(schema)}`;
+      }
+      return { ok: false, output };
+    },
+  };
+
+  const depth = depthFor(manager);
+  const serverOpt = { server: { type: "string", description: "only list this server" } };
+
+  const prompts: Tool = {
+    schema: {
+      name: "mcp_prompts",
+      description: "List prompts on connected MCP servers as 'server/name — description (args: a, b*)', * = required. Render one with mcp_prompt.",
+      args: { type: "object", properties: serverOpt, additionalProperties: false },
+    },
+    kind: "read",
+    sequential: false,
+    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const server = strArg(rawArgs, "server");
+      let rows: McpPromptInfo[];
+      const notes: string[] = [];
+      if (server !== undefined) {
+        if (!manager.connectedNames().includes(server)) return notConnected(manager, server);
+        try {
+          rows = await depth.promptsOf(server, ctx.signal);
+        } catch (err) {
+          return { ok: false, output: `failed to list prompts on "${server}": ${message(err)}` };
+        }
+      } else {
+        const r = await depth.listPrompts(ctx.signal);
+        rows = r.prompts;
+        notes.push(...r.notes);
+      }
+      const lines = rows.map((p) => {
+        const args = p.arguments.map((a) => (a.required ? `${a.name}*` : a.name)).join(", ");
+        return `${p.server}/${p.name} — ${compact(p.description)}${args ? ` (args: ${args})` : ""}`;
+      });
+      if (lines.length === 0) {
+        lines.push(manager.connectedNames().length === 0 ? "no MCP servers connected" : `no prompts advertised by ${server === undefined ? "connected MCP servers" : `"${server}"`}`);
+      } else lines.push("", "render with mcp_prompt {server, name, args}");
+      return { ok: true, output: [...lines, ...notes.map((n) => `note: ${n}`)].join("\n"), data: rows };
+    },
+  };
+
+  const prompt: Tool = {
+    schema: {
+      name: "mcp_prompt",
+      description: "Render a prompt from an MCP server (prompts/get) as '[role] text' lines. Names and args via mcp_prompts.",
+      args: {
+        type: "object",
+        properties: {
+          server: { type: "string", description: "MCP server name" },
+          name: { type: "string", description: "prompt name on that server" },
+          args: { type: "object", description: "prompt arguments (string values)" },
+        },
+        required: ["server", "name"],
+        additionalProperties: false,
+      },
+    },
+    kind: "read",
+    interruptible: true,
+    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const server = strArg(rawArgs, "server");
+      const name = strArg(rawArgs, "name");
+      if (server === undefined || name === undefined) {
+        return { ok: false, output: 'mcp_prompt requires string "server" and "name" (discover them with mcp_prompts)' };
+      }
+      return depth.getPrompt(server, name, (rawArgs as { args?: unknown } | null | undefined)?.args, ctx.signal);
+    },
+  };
+
+  const resources: Tool = {
+    schema: {
+      name: "mcp_resources",
+      description: "List resources (and URI templates) on connected MCP servers as 'server uri — name: description [mime]'. Read one with mcp_read.",
+      args: { type: "object", properties: serverOpt, additionalProperties: false },
+    },
+    kind: "read",
+    sequential: false,
+    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const server = strArg(rawArgs, "server");
+      let index: McpResourceIndex;
+      const notes: string[] = [];
+      if (server !== undefined) {
+        if (!manager.connectedNames().includes(server)) return notConnected(manager, server);
+        try {
+          index = await depth.resourcesOf(server, ctx.signal);
+        } catch (err) {
+          return { ok: false, output: `failed to list resources on "${server}": ${message(err)}` };
+        }
+      } else {
+        const r = await depth.listResources(ctx.signal);
+        index = r.index;
+        notes.push(...r.notes);
+      }
+      const tail = (name: string, desc: string, mime: string | undefined): string =>
+        `${name || "(unnamed)"}${desc ? `: ${compact(desc)}` : ""}${mime ? ` [${mime}]` : ""}`;
+      const lines = [
+        ...index.resources.map((r) => `${r.server} ${r.uri} — ${tail(r.name, r.description, r.mimeType)}`),
+        ...index.templates.map((t) => `${t.server} template ${t.uriTemplate} — ${tail(t.name, t.description, t.mimeType)}`),
+      ];
+      if (lines.length === 0) {
+        lines.push(manager.connectedNames().length === 0 ? "no MCP servers connected" : `no resources advertised by ${server === undefined ? "connected MCP servers" : `"${server}"`}`);
+      } else lines.push("", "read with mcp_read {server, uri} (fill a template's {variables} first)");
+      return { ok: true, output: [...lines, ...notes.map((n) => `note: ${n}`)].join("\n"), data: index };
+    },
+  };
+
+  const read: Tool = {
+    schema: {
+      name: "mcp_read",
+      description: "Read one MCP resource by uri (resources/read): text as-is, binary as an annotated base64 blob; output capped at 10k chars.",
+      args: {
+        type: "object",
+        properties: {
+          server: { type: "string", description: "MCP server name" },
+          uri: { type: "string", description: "resource uri (from mcp_resources)" },
+        },
+        required: ["server", "uri"],
+        additionalProperties: false,
+      },
+    },
+    kind: "read",
+    interruptible: true,
+    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const server = strArg(rawArgs, "server");
+      const uri = strArg(rawArgs, "uri");
+      if (server === undefined || uri === undefined) {
+        return { ok: false, output: 'mcp_read requires string "server" and "uri" (discover them with mcp_resources)' };
+      }
+      return depth.readResource(server, uri, ctx.signal);
+    },
+  };
+
+  return [list, call, prompts, prompt, resources, read];
+}

package/src/mcp/transport.ts

@@ -0,0 +1,122 @@
+/** MCP transport construction + connect-error text (ported 2026-09-07 from the upstream harness's port #57/#76
+ *  split of client.ts; the move changes no behaviour). `buildTransport` maps a config + wire to the SDK transport:
+ *  the stdio child, streamable HTTP, or the legacy HTTP+SSE wire, with the static `headers` on every request and
+ *  the rovecode `OAuthClientProvider` when one applies (mcp/oauth.ts runtimeAuthProvider): the SDK injects
+ *  `Authorization: Bearer <access>` from it on every GET/POST of both url wires and runs its 401 → auth() pass;
+ *  `requestInit.headers` is spread LAST inside the SDK (client/streamableHttp.js _commonHeaders, sse.js alike), and the
+ *  factory hands out no provider when an Authorization header is configured, so static auth always wins.
+ *  `describeError` turns a connect failure into the failed[] / status-row / mcp_call text: the SDK's StreamableHTTPError
+ *  keeps the HTTP status only in `.code`, so a bare "Error POSTing to endpoint: nope" gets "(HTTP 500)" back; a 401 on a
+ *  url server (either wire), the SDK's UnauthorizedError and McpNeedsLoginError all become the short remedy
+ *  `needs login — run \`rovecode mcp login <name>\`` (≤ 80 chars for a 20-char name, so status.ts's clip keeps it whole) —
+ *  a 401 against a configured static Authorization header names that header instead. Never a token.
+ *
+ *  Lazy SDK (rovecode): this module, like client.ts, imports only TYPES at load. The MCP SDK is ~200 ms of module
+ *  evaluation (zod schemas for every protocol message) and used to be paid inside createRuntime, before the terminal
+ *  had painted anything; mcp.test.ts pins that importing client.ts pulls in no @modelcontextprotocol module. So the
+ *  SDK is loaded here once, on the first connect (`loadSdk`), and the error classes and the list_changed notification
+ *  schemas come out of that same load. `describeError` / `isSseOnlySignature` are synchronous: before the SDK has
+ *  loaded no SDK error can exist, so `sdkIfLoaded()` being null simply means the plain-message path. */
+
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { message, type McpServerConfig } from "./config.ts";
+import { McpNeedsLoginError, hasStaticAuthorization, needsLoginText } from "./shared.ts";
+
+/** Everything the manager needs from the SDK, loaded together on the connect path. */
+export interface Sdk {
+  Client: typeof import("@modelcontextprotocol/sdk/client/index.js").Client;
+  StdioClientTransport: typeof import("@modelcontextprotocol/sdk/client/stdio.js").StdioClientTransport;
+  getDefaultEnvironment: typeof import("@modelcontextprotocol/sdk/client/stdio.js").getDefaultEnvironment;
+  StreamableHTTPClientTransport: typeof import("@modelcontextprotocol/sdk/client/streamableHttp.js").StreamableHTTPClientTransport;
+  StreamableHTTPError: typeof import("@modelcontextprotocol/sdk/client/streamableHttp.js").StreamableHTTPError;
+  SSEClientTransport: typeof import("@modelcontextprotocol/sdk/client/sse.js").SSEClientTransport;
+  SseError: typeof import("@modelcontextprotocol/sdk/client/sse.js").SseError;
+  UnauthorizedError: typeof import("@modelcontextprotocol/sdk/client/auth.js").UnauthorizedError;
+  ToolListChangedNotificationSchema: typeof import("@modelcontextprotocol/sdk/types.js").ToolListChangedNotificationSchema;
+  PromptListChangedNotificationSchema: typeof import("@modelcontextprotocol/sdk/types.js").PromptListChangedNotificationSchema;
+  ResourceListChangedNotificationSchema: typeof import("@modelcontextprotocol/sdk/types.js").ResourceListChangedNotificationSchema;
+}
+
+let sdkPromise: Promise<Sdk> | null = null;
+let loaded: Sdk | null = null;
+
+/** The SDK, loaded once (all six modules together) — the first connect pays it, nothing at boot does. */
+export function loadSdk(): Promise<Sdk> {
+  sdkPromise ??= Promise.all([
+    import("@modelcontextprotocol/sdk/client/index.js"),
+    import("@modelcontextprotocol/sdk/client/stdio.js"),
+    import("@modelcontextprotocol/sdk/client/streamableHttp.js"),
+    import("@modelcontextprotocol/sdk/client/sse.js"),
+    import("@modelcontextprotocol/sdk/client/auth.js"),
+    import("@modelcontextprotocol/sdk/types.js"),
+  ]).then(([index, stdio, http, sse, auth, types]) => {
+    loaded = {
+      Client: index.Client,
+      StdioClientTransport: stdio.StdioClientTransport,
+      getDefaultEnvironment: stdio.getDefaultEnvironment,
+      StreamableHTTPClientTransport: http.StreamableHTTPClientTransport,
+      StreamableHTTPError: http.StreamableHTTPError,
+      SSEClientTransport: sse.SSEClientTransport,
+      SseError: sse.SseError,
+      UnauthorizedError: auth.UnauthorizedError,
+      ToolListChangedNotificationSchema: types.ToolListChangedNotificationSchema,
+      PromptListChangedNotificationSchema: types.PromptListChangedNotificationSchema,
+      ResourceListChangedNotificationSchema: types.ResourceListChangedNotificationSchema,
+    };
+    return loaded;
+  });
+  return sdkPromise;
+}
+
+/** The SDK once loadSdk() has resolved; null before (and then no SDK-built error can exist yet). */
+export function sdkIfLoaded(): Sdk | null {
+  return loaded;
+}
+
+/** The initialize POST hitting an SSE-only server: 404 (no such route) or 405 (GET-only route). */
+export function isSseOnlySignature(err: unknown): boolean {
+  const sdk = loaded;
+  return sdk !== null && err instanceof sdk.StreamableHTTPError && (err.code === 404 || err.code === 405);
+}
+
+/** a 401 from either url wire: StreamableHTTPError / SseError carry it in `.code`; the SSE POST path only in its text */
+function isUnauthorized(err: unknown): boolean {
+  const sdk = loaded;
+  if (sdk !== null && (err instanceof sdk.StreamableHTTPError || err instanceof sdk.SseError)) return err.code === 401;
+  return err instanceof Error && /\(HTTP 401\)/.test(err.message);
+}
+
+/** Error text for failed[] / status rows / mcp_call (see the header). */
+export function describeError(err: unknown, config: Pick<McpServerConfig, "name" | "headers">): string {
+  if (err instanceof McpNeedsLoginError) return err.message;
+  const sdk = loaded;
+  if ((sdk !== null && err instanceof sdk.UnauthorizedError) || isUnauthorized(err)) {
+    return hasStaticAuthorization(config) ? "HTTP 401 — the configured Authorization header was rejected" : needsLoginText(config.name);
+  }
+  const text = message(err);
+  return sdk !== null && err instanceof sdk.StreamableHTTPError && typeof err.code === "number" && err.code > 0 && !text.includes(String(err.code)) ? `${text} (HTTP ${err.code})` : text;
+}
+
+/** The SDK transport for one config on one wire (the http → sse fallback calls this twice). */
+export async function buildTransport(config: McpServerConfig, wire: McpServerConfig["transport"], authProvider?: OAuthClientProvider): Promise<Transport> {
+  const sdk = await loadSdk();
+  if (wire === "http" || wire === "sse") {
+    if (config.url === undefined) throw new Error(`${wire} server "${config.name}" has no url`);
+    // headers (auth tokens etc.) ride on every request via fetch's RequestInit — the SSE transport applies them to
+    // the GET stream and to each POST alike; the provider (port #76) is the SDK's own bearer + 401-refresh seam
+    const opts = {
+      ...(config.headers ? { requestInit: { headers: config.headers } } : {}),
+      ...(authProvider ? { authProvider } : {}),
+    };
+    const url = new URL(config.url);
+    return wire === "http" ? new sdk.StreamableHTTPClientTransport(url, opts) : new sdk.SSEClientTransport(url, opts);
+  }
+  if (config.command === undefined) throw new Error(`stdio server "${config.name}" has no command`);
+  return new sdk.StdioClientTransport({
+    command: config.command,
+    args: config.args ?? [],
+    env: { ...sdk.getDefaultEnvironment(), ...(config.env ?? {}) },
+    stderr: "ignore",
+  });
+}

package/src/mcp/trust.ts

@@ -0,0 +1,25 @@
+/** Trust for PROJECT MCP files (.rovecode/mcp.json, .mcp.json) — since 2026-09-07 one name for the general project
+ *  trust store in core/trust.ts (the same store and the same bar as project plugins: ~/.rovecode/plugins.json `trusted`,
+ *  keyed by the file's absolute path, value = sha256 of its bytes). The store lives in the USER home, so a repo cannot
+ *  trust itself; any edit to the file changes the digest and the gate asks again. An untrusted file contributes NOTHING
+ *  (config.ts loadMcpConfig skips it with one warning) — absence, not "loaded but marked". Berkay's choice on top of the
+ *  gate: files he writes himself through `mcp add --project` / `mcp remove --project` are trusted the moment he approves
+ *  them (market-install.ts records the digest right after the write); hand-edited and cloned files ask.
+ *  `rovecode mcp trust` acts on the MCP files only; `rovecode trust` (cli/trust-cmd.ts) on every gated project file. */
+
+import { existsSync } from "node:fs";
+import { fileDigest, fileTrustStatus, trustFile, trustedPredicate, untrustFile, type TrustStatus } from "../core/trust.ts";
+import { mcpConfigFiles } from "./config.ts";
+
+export { fileDigest, trustedPredicate };
+export type { TrustStatus };
+
+export const mcpTrustStatus = fileTrustStatus;
+export const trustMcpFile = trustFile;
+export const untrustMcpFile = untrustFile;
+
+/** the project files that exist in this checkout — what `mcp trust` / `mcp show` act on */
+export function projectMcpFiles(cwd: string): string[] {
+  const f = mcpConfigFiles(cwd);
+  return [f.harvest, f.project].filter((p) => existsSync(p));
+}