chainlesschain 0.162.101 → 0.162.103

package/src/lib/cli-arg.js

@@ -0,0 +1,41 @@
+/**
+ * cli-arg — validating commander option coercers.
+ *
+ * Bare `parseInt` / `parseFloat` / `Number` used as a commander coercer
+ * (`.option("--limit <n>", "...", parseInt)`) silently yield NaN on bad input
+ * (`--limit abc`), threading NaN into whatever the action does with the option.
+ * These factories validate at parse time and raise a commander
+ * `InvalidArgumentError`, so a typo fails with the standard
+ * `error: option '--limit <n>' argument 'abc' is invalid` message and exit 1 —
+ * instead of a silently-corrupt run.
+ *
+ * Drop-in replacements:
+ *   .option("--limit <n>", "...", parseInt)      ->  intArg("--limit")
+ *   .option("--rate <n>",  "...", parseFloat)    ->  floatArg("--rate")
+ *   .option("--eps <n>",   "...", Number)        ->  floatArg("--eps")
+ *
+ * Behaviour for valid and omitted values is identical to the bare coercer
+ * (the coercer only runs when the option is supplied with a value); only the
+ * NaN-on-bad-input case changes.
+ *
+ * @param {string} name  option label for the message (e.g. "--limit")
+ * @param {{min?: number, max?: number}} [opts]
+ */
+import { InvalidArgumentError } from "commander";
+import { numericOption } from "./cli-numeric.js";
+
+function makeArg(integer) {
+  return (name, opts = {}) =>
+    (raw) => {
+      try {
+        return numericOption(raw, { ...opts, name, integer });
+      } catch (err) {
+        throw new InvalidArgumentError(err.message);
+      }
+    };
+}
+
+export const intArg = makeArg(true);
+export const floatArg = makeArg(false);
+
+export default { intArg, floatArg };

package/src/lib/cli-numeric.js

@@ -10,7 +10,9 @@
  * @param {*} raw  the option value (string from commander, or undefined)
  * @param {object} [opts]
  * @param {string} [opts.name="value"]   label for error messages (e.g. "--limit")
- * @param {boolean} [opts.integer=false] parse as integer (parseInt) vs float (Number)
+ * @param {boolean} [opts.integer=false] require a whole number (rejects 1.5);
+ *                                       parsing is strict either way (Number,
+ *                                       not parseInt — "12abc" is rejected)
  * @param {number} [opts.min]            inclusive lower bound
  * @param {number} [opts.max]            inclusive upper bound
  * @param {number} [opts.fallback]       returned for missing/invalid input; when
@@ -26,8 +28,15 @@ export function numericOption(raw, opts = {}) {
   };
 
   if (raw == null || raw === "") return fail(`${name} is required`);
-  const n = integer ? parseInt(raw, 10) : Number(raw);
-  if (!Number.isFinite(n)) {
+  if (typeof raw === "string" && raw.trim() === "")
+    return fail(`${name} is required`);
+  // Number() (NOT parseInt) so trailing junk is rejected instead of silently
+  // truncated: parseInt("12abc") === 12 and parseInt("0x10", 10) === 0 would
+  // slip a corrupt value through. Number("12abc") is NaN; whole numbers given
+  // via exponent ("1e3" -> 1000) still parse, and a fractional value is
+  // rejected in integer mode.
+  const n = Number(raw);
+  if (!Number.isFinite(n) || (integer && !Number.isInteger(n))) {
     return fail(
       `${name} must be a ${integer ? "whole " : ""}number (got ${JSON.stringify(String(raw))})`,
     );

package/src/lib/instinct-manager.js

@@ -20,6 +20,70 @@ export function ensureInstinctsTable(db) {
   `);
 }
 
+/** datetime('now')-style timestamp for rows missing one on import. */
+function _instinctNowSqlite() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+
+/**
+ * Export ALL instincts (full dump) for §8.3 cross-device backup. Deterministic
+ * order so the same DB exports identically.
+ */
+export function exportInstincts(db) {
+  ensureInstinctsTable(db);
+  return db
+    .prepare(
+      `SELECT id, category, pattern, confidence, occurrences, last_seen, created_at
+       FROM instincts ORDER BY created_at ASC, id ASC`,
+    )
+    .all();
+}
+
+/**
+ * Import instincts (§8.3 restore): idempotent upsert by id — preserves created_at,
+ * updates category/pattern/confidence/occurrences/last_seen. Never aborts mid-batch.
+ */
+export function importInstincts(db, rows) {
+  ensureInstinctsTable(db);
+  if (!Array.isArray(rows)) {
+    throw new Error("importInstincts: rows must be a JSON array");
+  }
+  const stmt = db.prepare(
+    `INSERT INTO instincts (id, category, pattern, confidence, occurrences, last_seen, created_at)
+     VALUES (@id, @category, @pattern, @confidence, @occurrences, @last_seen, @created_at)
+     ON CONFLICT(id) DO UPDATE SET
+       category = excluded.category,
+       pattern = excluded.pattern,
+       confidence = excluded.confidence,
+       occurrences = excluded.occurrences,
+       last_seen = excluded.last_seen`,
+  );
+  let imported = 0;
+  let failed = 0;
+  const errors = [];
+  for (const r of rows) {
+    try {
+      if (!r || !r.id || !r.category || !r.pattern) {
+        throw new Error("invalid instinct (need id + category + pattern)");
+      }
+      stmt.run({
+        id: String(r.id),
+        category: r.category,
+        pattern: r.pattern,
+        confidence: typeof r.confidence === "number" ? r.confidence : 0.5,
+        occurrences: Number.isInteger(r.occurrences) ? r.occurrences : 1,
+        last_seen: r.last_seen || _instinctNowSqlite(),
+        created_at: r.created_at || _instinctNowSqlite(),
+      });
+      imported += 1;
+    } catch (e) {
+      failed += 1;
+      if (errors.length < 10) errors.push({ id: r && r.id, error: e.message });
+    }
+  }
+  return { ok: failed === 0, imported, failed, errors };
+}
+
 function generateId() {
   const hex = () =>
     Math.floor(Math.random() * 0x10000)

package/src/lib/learning/learning-tables.js

@@ -64,3 +64,86 @@ export function ensureLearningTables(db) {
     )
   `);
 }
+
+/** datetime('now')-style timestamp for rows missing one on import. */
+function _learningNowSqlite() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+
+/**
+ * Export ALL learning trajectories (full dump) for §8.3 cross-device backup.
+ * Includes the synthesized_skill linkage (synthesized skills travel with the
+ * trajectories that produced them). The learning_trajectory_tags side-table is
+ * derived and intentionally not exported in v1.
+ */
+export function exportTrajectories(db) {
+  ensureLearningTables(db);
+  return db
+    .prepare(
+      `SELECT id, session_id, user_intent, tool_chain, tool_count, final_response,
+              outcome_score, outcome_source, complexity_level, synthesized_skill,
+              created_at, completed_at
+       FROM learning_trajectories ORDER BY created_at ASC, id ASC`,
+    )
+    .all();
+}
+
+/**
+ * Import learning trajectories (§8.3 restore): idempotent upsert by id —
+ * preserves created_at, updates the rest. Never aborts mid-batch.
+ */
+export function importTrajectories(db, rows) {
+  ensureLearningTables(db);
+  if (!Array.isArray(rows)) {
+    throw new Error("importTrajectories: rows must be a JSON array");
+  }
+  const stmt = db.prepare(
+    `INSERT INTO learning_trajectories
+       (id, session_id, user_intent, tool_chain, tool_count, final_response,
+        outcome_score, outcome_source, complexity_level, synthesized_skill,
+        created_at, completed_at)
+     VALUES (@id, @session_id, @user_intent, @tool_chain, @tool_count, @final_response,
+             @outcome_score, @outcome_source, @complexity_level, @synthesized_skill,
+             @created_at, @completed_at)
+     ON CONFLICT(id) DO UPDATE SET
+       session_id = excluded.session_id,
+       user_intent = excluded.user_intent,
+       tool_chain = excluded.tool_chain,
+       tool_count = excluded.tool_count,
+       final_response = excluded.final_response,
+       outcome_score = excluded.outcome_score,
+       outcome_source = excluded.outcome_source,
+       complexity_level = excluded.complexity_level,
+       synthesized_skill = excluded.synthesized_skill,
+       completed_at = excluded.completed_at`,
+  );
+  let imported = 0;
+  let failed = 0;
+  const errors = [];
+  for (const r of rows) {
+    try {
+      if (!r || !r.id || !r.session_id) {
+        throw new Error("invalid trajectory (need id + session_id)");
+      }
+      stmt.run({
+        id: String(r.id),
+        session_id: String(r.session_id),
+        user_intent: r.user_intent ?? null,
+        tool_chain: r.tool_chain ?? "[]",
+        tool_count: Number.isInteger(r.tool_count) ? r.tool_count : 0,
+        final_response: r.final_response ?? null,
+        outcome_score: typeof r.outcome_score === "number" ? r.outcome_score : null,
+        outcome_source: r.outcome_source ?? null,
+        complexity_level: r.complexity_level ?? "simple",
+        synthesized_skill: r.synthesized_skill ?? null,
+        created_at: r.created_at || _learningNowSqlite(),
+        completed_at: r.completed_at ?? null,
+      });
+      imported += 1;
+    } catch (e) {
+      failed += 1;
+      if (errors.length < 10) errors.push({ id: r && r.id, error: e.message });
+    }
+  }
+  return { ok: failed === 0, imported, failed, errors };
+}

package/src/lib/mcp-oauth.js

@@ -410,7 +410,7 @@ function defaultOpenBrowser(url) {
 }
 
 /** Wait for the OAuth redirect on a localhost callback server; resolve {code,state}. */
-function waitForCallback({
+export function waitForCallback({
   port,
   host = "127.0.0.1",
   path = "/callback",
@@ -446,7 +446,15 @@ function waitForCallback({
       server.close();
       reject(new Error("timed out waiting for the OAuth callback"));
     }, timeout);
-    server.on("error", reject);
+    // Backstop timer should never keep the process alive on its own (the
+    // listening server does that); the loop exits promptly once it closes.
+    timer.unref?.();
+    server.on("error", (err) => {
+      // Without clearing the timer here, a bind failure (e.g. port in use)
+      // left it pending for the full `timeout`, delaying process exit.
+      clearTimeout(timer);
+      reject(err);
+    });
     server.listen(port, host);
   });
 }

package/src/lib/memory-manager.js

@@ -133,6 +133,73 @@ export function listMemory(db, options = {}) {
     .all(limit);
 }
 
+/**
+ * Export ALL memory entries (full dump, no limit) for §8.3 cross-device backup.
+ * Returns rows with id/content/category/importance/source/created_at/updated_at,
+ * ordered deterministically so the same DB exports identically.
+ */
+export function exportMemory(db) {
+  ensureMemoryTable(db);
+  return db
+    .prepare(
+      `SELECT id, content, category, importance, source, created_at, updated_at
+       FROM memory_entries ORDER BY created_at ASC, id ASC`,
+    )
+    .all();
+}
+
+/** datetime('now')-style timestamp for entries missing one on import. */
+function _nowSqlite() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+
+/**
+ * Import memory entries (§8.3 backup restore): idempotent upsert by id —
+ * preserves the original created_at, updates content/category/importance/source/
+ * updated_at. Never aborts mid-batch; returns {ok, imported, failed, errors}.
+ */
+export function importMemory(db, entries) {
+  ensureMemoryTable(db);
+  if (!Array.isArray(entries)) {
+    throw new Error("importMemory: entries must be a JSON array");
+  }
+  const stmt = db.prepare(
+    `INSERT INTO memory_entries
+       (id, content, category, importance, source, created_at, updated_at)
+     VALUES (@id, @content, @category, @importance, @source, @created_at, @updated_at)
+     ON CONFLICT(id) DO UPDATE SET
+       content = excluded.content,
+       category = excluded.category,
+       importance = excluded.importance,
+       source = excluded.source,
+       updated_at = excluded.updated_at`,
+  );
+  let imported = 0;
+  let failed = 0;
+  const errors = [];
+  for (const e of entries) {
+    try {
+      if (!e || !e.id || typeof e.content !== "string") {
+        throw new Error("invalid memory entry (need id + content)");
+      }
+      stmt.run({
+        id: String(e.id),
+        content: e.content,
+        category: e.category || "general",
+        importance: Number.isInteger(e.importance) ? e.importance : 3,
+        source: e.source || "user",
+        created_at: e.created_at || _nowSqlite(),
+        updated_at: e.updated_at || _nowSqlite(),
+      });
+      imported += 1;
+    } catch (err) {
+      failed += 1;
+      if (errors.length < 10) errors.push({ id: e && e.id, error: err.message });
+    }
+  }
+  return { ok: failed === 0, imported, failed, errors };
+}
+
 /**
  * Delete a memory entry
  */

package/src/lib/personal-data-hub-wiring.js

@@ -29,11 +29,20 @@ import { mkdirSync } from "node:fs";
 // Hub package is CJS; in ESM we default-import then destructure (Node 22
 // won't let us name-import a CJS module unless it ships a separate ESM
 // shim, which we don't).
-import hub from "@chainlesschain/personal-data-hub";
-import wechatAdapterModule from "@chainlesschain/personal-data-hub/adapters/wechat";
-const { bootstrapWechatAdapter, probeWeChatEnv } = wechatAdapterModule;
-const {
-  LocalVault,
+// PDH is loaded LAZILY (not a top-level static import) so that merely
+// importing this wiring module — which happens on EVERY `cc` invocation,
+// because index.js statically pulls in commands/hub.js (getHub) AND the
+// agent/chat/serve/ui runtime chain (ws pdh-protocol → this wiring) — does
+// NOT eagerly evaluate the entire personal-data-hub adapter graph. Wins:
+//   • Robustness: a partial/corrupt pdh install (e.g. an interrupted
+//     `npm i -g` that left adapter files unwritten) no longer bricks
+//     unrelated commands like `cc -v` with a cryptic ERR_MODULE_NOT_FOUND.
+//     pdh only loads when a `cc hub …` / web-shell hub topic actually runs.
+//   • Startup cost: non-hub commands skip loading 50+ adapter modules.
+// The bindings below are populated by ensurePdhLoaded(), which initHub() and
+// initHubMinimal() await before touching any of them.
+let bootstrapWechatAdapter, probeWeChatEnv;
+let LocalVault,
   AdapterRegistry,
   AnalysisEngine,
   MockAdapter,
@@ -124,8 +133,125 @@ const {
   EntityResolverEmbeddingStage,
   EntityResolverLLMStage,
   runAnalysisSkill,
-  ANALYSIS_SKILL_NAMES,
-} = hub;
+  ANALYSIS_SKILL_NAMES;
+
+let _pdhLoadPromise = null;
+/**
+ * Lazily import the personal-data-hub package + wechat adapter and populate
+ * the module-level binding holders above. Memoized so concurrent
+ * getHub()/getHubMinimal() callers share one load. Must be awaited by any
+ * code path that uses a pdh binding (initHub / initHubMinimal).
+ */
+function ensurePdhLoaded() {
+  if (!_pdhLoadPromise) {
+    _pdhLoadPromise = (async () => {
+      const hubMod = await import("@chainlesschain/personal-data-hub");
+      const hub = hubMod.default || hubMod;
+      // Composed specifier dodges vite/vitest static import-analysis of
+      // subpath exports (same trick as loadAIChatHealthChecker below).
+      const wechatSpec =
+        "@chainlesschain/personal-data-hub" + "/adapters/wechat";
+      const waMod = await import(wechatSpec);
+      const wechatAdapterModule = waMod.default || waMod;
+      ({ bootstrapWechatAdapter, probeWeChatEnv } = wechatAdapterModule);
+      ({
+        LocalVault,
+        AdapterRegistry,
+        AnalysisEngine,
+        MockAdapter,
+        OllamaClient,
+        CcKgSink,
+        CcRagSink,
+        FileKeyProvider,
+        generateKeyHex,
+        EmailAdapter,
+        AlipayBillAdapter,
+        SystemDataAndroidAdapter,
+        BrowserHistoryChromeAdapter,
+        BrowserHistoryEdgeAdapter,
+        VSCodeAdapter,
+        WinRecentAdapter,
+        GitActivityAdapter,
+        ShellHistoryAdapter,
+        LocalFilesAdapter,
+        BilibiliAdapter,
+        WeiboAdapter,
+        ZhihuAdapter,
+        DoubanAdapter,
+        BossZhipinAdapter,
+        CsdnAdapter,
+        DongchediAdapter,
+        TianyanchaAdapter,
+        DouyinAdapter,
+        XiaohongshuAdapter,
+        ToutiaoAdapter,
+        KuaishouAdapter,
+        GenshinAdapter,
+        HonorOfKingsAdapter,
+        ZuoyebangAdapter,
+        AlipayAdapter,
+        HuaweiLearningAdapter,
+        QQAdapter,
+        WeChatPcAdapter,
+        QQPcAdapter,
+        AppleHealthAdapter,
+        NeteaseMusicAdapter,
+        KugouMusicAdapter,
+        QQMusicAdapter,
+        XimalayaAdapter,
+        FanqieReadingAdapter,
+        QimaoReadingAdapter,
+        JoyrunAdapter,
+        KeepAdapter,
+        DidiConsumerAdapter,
+        MercedesMeAdapter,
+        IqiyiVideoAdapter,
+        TencentVideoAdapter,
+        XiguaVideoAdapter,
+        WeReadAdapter,
+        WpsDocAdapter,
+        TencentDocsAdapter,
+        BaiduNetdiskAdapter,
+        CamScannerDocAdapter,
+        IXiamenAdapter,
+        MeiyouAdapter,
+        TaxAdapter,
+        CmbcBankAdapter,
+        BocBankAdapter,
+        BankcommBankAdapter,
+        IcbcBankAdapter,
+        DcepAdapter,
+        Tmri12123Adapter,
+        DingTalkPcAdapter,
+        FeishuPcAdapter,
+        WeWorkPcAdapter,
+        BaiduMapAdapter,
+        TencentMapAdapter,
+        JdAdapter,
+        MeituanAdapter,
+        ElemeAdapter,
+        PinduoduoAdapter,
+        DianpingAdapter,
+        XianyuAdapter,
+        VipshopAdapter,
+        Train12306Adapter,
+        TaobaoAdapter,
+        CtripAdapter,
+        TongchengAdapter,
+        DidiAdapter,
+        AmapAdapter,
+        TelegramAdapter,
+        WhatsAppAdapter,
+        EntityResolver,
+        EntityResolverEmbeddingStage,
+        EntityResolverLLMStage,
+        runAnalysisSkill,
+        ANALYSIS_SKILL_NAMES,
+      } = hub);
+    })();
+  }
+  return _pdhLoadPromise;
+}
 import {
   readFileSync,
   writeFileSync,
@@ -209,6 +335,7 @@ export function resolveHubDir() {
 }
 
 async function initHub() {
+  await ensurePdhLoaded();
   // Phase 1c: hoisted so the hub-level `bilibiliAdbSync` method can reuse
   // the same bridge instance the system-data-android adapter wires below.
   // Single bridge per hub keeps `bilibili.cookies` extension state /
@@ -1490,6 +1617,7 @@ let _hubMinimal = null;
 let _hubMinimalInitPromise = null;
 
 async function initHubMinimal() {
+  await ensurePdhLoaded();
   const hubDir = resolveHubDir();
   mkdirSync(hubDir, { recursive: true });
   mkdirSync(join(hubDir, "keys"), { recursive: true });

package/src/lib/plan-mode.js

@@ -31,6 +31,7 @@ export const PlanState = {
   APPROVED: "approved",
   EXECUTING: "executing",
   COMPLETED: "completed",
+  FAILED: "failed",
   REJECTED: "rejected",
 };
 
@@ -499,10 +500,10 @@ export class PlanModeManager extends EventEmitter {
     });
 
     const allDone = results.every((r) => r.success);
-    this.state = allDone ? PlanState.COMPLETED : PlanState.COMPLETED;
+    this.state = allDone ? PlanState.COMPLETED : PlanState.FAILED;
     this.currentPlan.status = allDone
       ? PlanState.COMPLETED
-      : PlanState.COMPLETED;
+      : PlanState.FAILED;
 
     return { results, success: allDone };
   }

package/src/repl/__tests__/mcp-prompt.test.js

@@ -0,0 +1,155 @@
+"use strict";
+
+/**
+ * mcp-prompt tests (previously untested) — the pure core that surfaces MCP
+ * server prompts as `/mcp__<server>__<prompt>` slash commands. Covers
+ * parseMcpPromptCommand (server/name split incl. `__` in names, JSON-object args
+ * vs non-JSON tail, reject non-mcp / missing parts), renderPromptMessages
+ * (text + embedded resource text, ignore binary, single vs array content),
+ * expandMcpPrompt (parse -> getPrompt -> render, null for non-mcp, throw when no
+ * client) and renderMcpSurface (overview / empty / no-client). No I/O.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+  parseMcpPromptCommand,
+  renderPromptMessages,
+  expandMcpPrompt,
+  renderMcpSurface,
+} from "../mcp-prompt.js";
+
+describe("parseMcpPromptCommand", () => {
+  it("returns null for non-mcp lines", () => {
+    expect(parseMcpPromptCommand("hello")).toBe(null);
+    expect(parseMcpPromptCommand("/other__a__b")).toBe(null);
+    expect(parseMcpPromptCommand("")).toBe(null);
+  });
+
+  it("parses server and prompt name with empty args", () => {
+    expect(parseMcpPromptCommand("/mcp__github__review")).toEqual({
+      server: "github",
+      name: "review",
+      args: {},
+    });
+  });
+
+  it("keeps '__' inside the prompt name", () => {
+    expect(parseMcpPromptCommand("/mcp__srv__deep__name").name).toBe(
+      "deep__name",
+    );
+  });
+
+  it("parses a trailing JSON object as args", () => {
+    expect(parseMcpPromptCommand('/mcp__s__p {"a":1,"b":"x"}').args).toEqual({
+      a: 1,
+      b: "x",
+    });
+  });
+
+  it("treats a non-JSON tail as { input: tail }", () => {
+    expect(parseMcpPromptCommand("/mcp__s__p just some text").args).toEqual({
+      input: "just some text",
+    });
+  });
+
+  it("treats a JSON array tail as { input } (not an object)", () => {
+    expect(parseMcpPromptCommand("/mcp__s__p [1,2]").args).toEqual({
+      input: "[1,2]",
+    });
+  });
+
+  it("returns null when server or prompt is missing", () => {
+    expect(parseMcpPromptCommand("/mcp__srv")).toBe(null); // < 3 parts
+    expect(parseMcpPromptCommand("/mcp____p")).toBe(null); // empty server
+  });
+});
+
+describe("renderPromptMessages", () => {
+  it("returns '' when there are no messages", () => {
+    expect(renderPromptMessages(null)).toBe("");
+    expect(renderPromptMessages({ messages: [] })).toBe("");
+  });
+
+  it("joins text blocks with blank lines", () => {
+    const r = renderPromptMessages({
+      messages: [
+        { content: [{ type: "text", text: "one" }] },
+        { content: [{ type: "text", text: "two" }] },
+      ],
+    });
+    expect(r).toBe("one\n\ntwo");
+  });
+
+  it("includes embedded resource text and ignores binary/unknown blocks", () => {
+    const r = renderPromptMessages({
+      messages: [
+        {
+          content: [
+            { type: "text", text: "T" },
+            { type: "resource", resource: { text: "R" } },
+            { type: "image", data: "..." },
+            null,
+          ],
+        },
+      ],
+    });
+    expect(r).toBe("T\n\nR");
+  });
+
+  it("handles content given as a single block (not an array)", () => {
+    const r = renderPromptMessages({
+      messages: [{ content: { type: "text", text: "solo" } }],
+    });
+    expect(r).toBe("solo");
+  });
+});
+
+describe("expandMcpPrompt", () => {
+  it("returns null for a non-mcp line", async () => {
+    expect(await expandMcpPrompt("hi", {})).toBe(null);
+  });
+
+  it("throws when no MCP client is connected", async () => {
+    await expect(expandMcpPrompt("/mcp__s__p", null)).rejects.toThrow(
+      /No MCP servers/,
+    );
+  });
+
+  it("calls getPrompt with parsed args and renders the result", async () => {
+    const getPrompt = vi.fn(async () => ({
+      messages: [{ content: [{ type: "text", text: "rendered" }] }],
+    }));
+    const out = await expandMcpPrompt('/mcp__s__p {"k":1}', { getPrompt });
+    expect(getPrompt).toHaveBeenCalledWith("s", "p", { k: 1 });
+    expect(out).toBe("rendered");
+  });
+});
+
+describe("renderMcpSurface", () => {
+  it("reports when no client is connected", () => {
+    expect(renderMcpSurface(null)).toMatch(/No MCP servers/);
+  });
+
+  it("lists resources and prompts with counts", () => {
+    const surface = renderMcpSurface({
+      listResources: () => [{ uri: "file://x", server: "fs", name: "X" }],
+      listPrompts: () => [
+        { server: "gh", name: "review", description: "code review" },
+      ],
+    });
+    expect(surface).toContain("MCP resources (1):");
+    expect(surface).toContain("file://x [fs] — X");
+    expect(surface).toContain("MCP prompts (1):");
+    expect(surface).toContain("/mcp__gh__review — code review");
+  });
+
+  it("notes when servers expose nothing", () => {
+    const surface = renderMcpSurface({
+      listResources: () => [],
+      listPrompts: () => [],
+    });
+    expect(surface).toContain(
+      "(connected servers expose no resources or prompts)",
+    );
+  });
+});