@pi-harness/pi-harness 0.1.14 → 0.1.16

package/packages/core/test/mcp-client.test.ts

@@ -1,1037 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Context } from "@deepseek-ai/cordis";
-import { afterEach, describe, expect, test, vi } from "vitest";
-import mcpClientPlugin from "../src/plugins/mcp-client.js";
-import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-});
-
-async function createFixture(options?: { servers?: Array<{ id: string; command: string[]; autoStart?: boolean }>; launchCwd?: string; loadPlugin?: boolean }) {
-  const cwd = await mkdtemp(join(tmpdir(), "pi-harness-mcp-client-workspace-"));
-  const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-mcp-client-agent-"));
-  temporaryDirectories.push(cwd, agentDir);
-  const context = new Context();
-  const tools = new PiToolRegistry();
-  const panels = new PiPluginUiRegistry();
-  context.provide("piHarnessLaunch", { cwd: options?.launchCwd ?? cwd, agentDir, args: [], requestExit() {} });
-  context.provide("piTools", tools);
-  context.provide("piPluginUi", panels);
-  if (options?.loadPlugin !== false) await context.plugin(mcpClientPlugin, options?.servers === undefined ? {} : { servers: options.servers });
-  return { context, cwd, tools, panels };
-}
-
-function tool(tools: PiToolRegistry, name: string) {
-  const result = tools.snapshot().customTools.find((candidate) => candidate.name === name);
-  if (result === undefined) throw new Error(`${name} was not registered`);
-  return result;
-}
-
-async function writeServer(cwd: string, body: string): Promise<string> {
-  const path = join(cwd, `server-${Math.random().toString(16).slice(2)}.mjs`);
-  await writeFile(path, body, "utf8");
-  return path;
-}
-
-describe("MCP client production boundaries", () => {
-  test("rejects unknown configuration before registering any surface", async () => {
-    const fixture = await createFixture({ loadPlugin: false });
-    try {
-      await expect(fixture.context.plugin(mcpClientPlugin, { unexpected: true } as never)).rejects.toThrow(/unknown.*unexpected/iu);
-      expect(fixture.tools.snapshot().customTools).toEqual([]);
-      await expect(fixture.panels.snapshot()).resolves.toEqual([]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("declares strict sequential schemas for every stateful tool", async () => {
-    const fixture = await createFixture();
-    try {
-      for (const name of [
-        "mcp_list_tools",
-        "mcp_call",
-        "mcp_server_start",
-        "mcp_server_status",
-        "mcp_server_stop",
-        "mcp_list_resources",
-        "mcp_read_resource",
-        "mcp_list_prompts",
-        "mcp_get_prompt",
-      ]) {
-        const candidate = tool(fixture.tools, name);
-        expect(candidate.executionMode, name).toBe("sequential");
-        expect(candidate.parameters, name).toMatchObject({ additionalProperties: false });
-      }
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects class instances as raw MCP parameter objects", async () => {
-    const fixture = await createFixture();
-    class Parameters {
-      readonly command = [process.execPath, "server.mjs"];
-    }
-    try {
-      await expect(tool(fixture.tools, "mcp_list_tools").execute("instance", new Parameters(), undefined, undefined, {} as never)).rejects.toThrow(
-        /parameters.*plain object/iu,
-      );
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rolls back every registered tool when panel registration fails", async () => {
-    const fixture = await createFixture({ loadPlugin: false });
-    fixture.panels.register({ id: "mcp-client-panel", pluginId: "fixture", title: "Fixture", read: () => ({}) });
-    try {
-      await expect(fixture.context.plugin(mcpClientPlugin, {})).rejects.toThrow(/panel is already registered: mcp-client-panel/iu);
-      expect(fixture.tools.snapshot().customTools).toEqual([]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rolls back registered surfaces when an auto-start server fails", async () => {
-    const fixture = await createFixture({ loadPlugin: false, servers: [{ id: "broken", command: ["/definitely/missing-mcp-server"], autoStart: true }] });
-    try {
-      await expect(
-        fixture.context.plugin(mcpClientPlugin, { servers: [{ id: "broken", command: ["/definitely/missing-mcp-server"], autoStart: true }] }),
-      ).rejects.toThrow();
-      expect(fixture.tools.snapshot().customTools).toEqual([]);
-      await expect(fixture.panels.snapshot()).resolves.toEqual([]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("strictly validates raw parameters without invoking accessors", async () => {
-    const fixture = await createFixture();
-    let accessed = false;
-    const params = {} as { command?: string[] };
-    Object.defineProperty(params, "command", {
-      enumerable: true,
-      get() {
-        accessed = true;
-        throw new Error("MCP accessor executed");
-      },
-    });
-    try {
-      await expect(tool(fixture.tools, "mcp_list_tools").execute("accessor", params, undefined, undefined, {} as never)).rejects.toThrow(
-        /parameters.*data properties/iu,
-      );
-      expect(accessed).toBe(false);
-      await expect(tool(fixture.tools, "mcp_server_status").execute("unknown", { unexpected: true }, undefined, undefined, {} as never)).rejects.toThrow(
-        /unknown property/iu,
-      );
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects portable shell wrapper names", async () => {
-    const fixture = await createFixture();
-    try {
-      for (const command of ["C:\\tools\\sh.exe", "C:\\tools\\bash.cmd", "C:\\tools\\powershell.bat", "C:\\tools\\cmd.com"]) {
-        await expect(
-          tool(fixture.tools, "mcp_list_tools").execute("shell", { command: [command, "server.js"] }, undefined, undefined, {} as never),
-        ).rejects.toThrow(/shell wrapper/iu);
-      }
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("cancels and reaps a one-shot server when the plugin is disposed", async () => {
-    const fixture = await createFixture();
-    const requested = join(fixture.cwd, "requested");
-    const server = await writeServer(
-      fixture.cwd,
-      `import { writeFileSync } from "node:fs";
-console.error("server diagnostic");
-let buffer = "";
-const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n");
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "hang", version: "1" } } }); else if (message.method === "tools/list") writeFileSync(${JSON.stringify(requested)}, "yes"); } });`,
-    );
-    const controller = new AbortController();
-    const rejected = join(fixture.cwd, "rejected");
-    const pending = tool(fixture.tools, "mcp_list_tools").execute(
-      "dispose",
-      { command: [process.execPath, server] },
-      controller.signal,
-      undefined,
-      {} as never,
-    );
-    let rejection: unknown;
-    void pending.catch(async (error: unknown) => {
-      rejection = error;
-      await writeFile(rejected, "yes", "utf8");
-    });
-    try {
-      await vi.waitFor(() => expect(existsSync(requested)).toBe(true));
-      await fixture.context.fiber.dispose();
-      await vi.waitFor(() => expect(existsSync(rejected)).toBe(true), { timeout: 500 });
-      expect(rejection).toMatchObject({ message: "MCP client plugin disposed" });
-    } finally {
-      controller.abort(new Error("test cleanup"));
-      await pending.catch(() => undefined);
-    }
-  });
-
-  test("detaches and bounds remote inventories before publishing the panel", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "inventory", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: Array.from({ length: 40 }, (_, index) => ({ name: "tool-" + index, description: "d".repeat(1000), inputSchema: { type: "object" } })) } }); } });`,
-    );
-    try {
-      const result = await tool(fixture.tools, "mcp_list_tools").execute("list", { command: [process.execPath, server] }, undefined, undefined, {} as never);
-      (result.details as { tools: Array<{ name: string }> }).tools[0]!.name = "mutated-through-tool";
-      const first = await fixture.panels.snapshot();
-      expect(first).toMatchObject([
-        {
-          id: "mcp-client-panel",
-          data: {
-            inventory: { tools: { total: 40, shown: 20, truncated: true }, resources: { total: 0 }, prompts: { total: 0 } },
-            limits: { responseBytes: 1_048_576, commandArgs: 32, argumentBytes: 4_096, requestTimeoutMs: 30_000, panelItems: 20 },
-          },
-        },
-      ]);
-      const data = first[0]?.data as { tools: Array<{ name: string }> };
-      expect(data.tools).toHaveLength(20);
-      expect(data.tools[0]?.name).toBe("tool-0");
-      data.tools[0]!.name = "mutated-through-panel";
-      const second = await fixture.panels.snapshot();
-      expect((second[0]?.data as { tools: Array<{ name: string }> }).tools[0]?.name).toBe("tool-0");
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("follows bounded pagination for one-shot and managed MCP inventories", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); const cursor = message.params?.cursor; if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "pagination", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: cursor === "tools-next" ? { tools: [{ name: "tool-2", inputSchema: { type: "object" } }] } : { tools: [{ name: "tool-1", inputSchema: { type: "object" } }], nextCursor: "tools-next" } }); else if (message.method === "resources/list") send({ jsonrpc: "2.0", id: message.id, result: cursor === "resources-next" ? { resources: [{ uri: "fixture://resource-2", name: "Resource 2" }] } : { resources: [{ uri: "fixture://resource-1", name: "Resource 1" }], nextCursor: "resources-next" } }); else if (message.method === "prompts/list") send({ jsonrpc: "2.0", id: message.id, result: cursor === "prompts-next" ? { prompts: [{ name: "prompt-2" }] } : { prompts: [{ name: "prompt-1" }], nextCursor: "prompts-next" } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("one-shot-pages", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).resolves.toMatchObject({ details: { tools: [{ name: "tool-1" }, { name: "tool-2" }] } });
-      await tool(fixture.tools, "mcp_server_start").execute(
-        "managed-pages-start",
-        { command: [process.execPath, server], serverId: "pages" },
-        undefined,
-        undefined,
-        {} as never,
-      );
-      await expect(
-        tool(fixture.tools, "mcp_list_resources").execute("resource-pages", { serverId: "pages" }, undefined, undefined, {} as never),
-      ).resolves.toMatchObject({ details: { resources: [{ uri: "fixture://resource-1" }, { uri: "fixture://resource-2" }] } });
-      await expect(
-        tool(fixture.tools, "mcp_list_prompts").execute("prompt-pages", { serverId: "pages" }, undefined, undefined, {} as never),
-      ).resolves.toMatchObject({ details: { prompts: [{ name: "prompt-1" }, { name: "prompt-2" }] } });
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects repeated MCP pagination cursors", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "cursor-loop", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: [], nextCursor: "same" } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("cursor-loop", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/repeated.*pagination cursor/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("copies nested tool arguments without invoking accessors", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "arguments", version: "1" } } }); else if (message.method === "tools/call") send({ jsonrpc: "2.0", id: message.id, result: { content: [{ type: "text", text: "called" }] } }); } });`,
-    );
-    let accessed = false;
-    const argumentsValue = {} as Record<string, unknown>;
-    Object.defineProperty(argumentsValue, "secret", {
-      enumerable: true,
-      get() {
-        accessed = true;
-        throw new Error("nested MCP accessor executed");
-      },
-    });
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "arguments-accessor",
-          { command: [process.execPath, server], name: "echo", arguments: argumentsValue },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/arguments.*data properties/iu);
-      expect(accessed).toBe(false);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects oversized tool arguments before starting a server", async () => {
-    const fixture = await createFixture();
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "oversized-arguments",
-          { command: ["/definitely/missing-mcp-server"], name: "echo", arguments: { payload: "x".repeat(70 * 1024) } },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/arguments.*64 KiB/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects excessively deep tool arguments", async () => {
-    const fixture = await createFixture();
-    let argumentsValue: Record<string, unknown> = {};
-    for (let depth = 0; depth < 40; depth += 1) argumentsValue = { nested: argumentsValue };
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "deep-arguments",
-          { command: ["/definitely/missing-mcp-server"], name: "echo", arguments: argumentsValue },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/arguments.*32 levels/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("cancels a managed request while it is waiting in the server queue", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-mcp-client-queue-"));
-    temporaryDirectories.push(cwd);
-    const firstRequested = join(cwd, "first-requested");
-    const server = await writeServer(
-      cwd,
-      `import { writeFileSync } from "node:fs"; let buffer = ""; let lists = 0; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "queue", version: "1" } } }); else if (message.method === "tools/list" && ++lists === 1) writeFileSync(${JSON.stringify(firstRequested)}, "yes"); } });`,
-    );
-    const fixture = await createFixture({ servers: [{ id: "queue", command: [process.execPath, server] }] });
-    await tool(fixture.tools, "mcp_server_start").execute("start", { serverId: "queue" }, undefined, undefined, {} as never);
-    const first = tool(fixture.tools, "mcp_list_tools").execute("first", { serverId: "queue" }, undefined, undefined, {} as never);
-    void first.catch(() => undefined);
-    const controller = new AbortController();
-    let secondOutcome: unknown;
-    let second: Promise<unknown> | undefined;
-    try {
-      await vi.waitFor(() => expect(existsSync(firstRequested)).toBe(true));
-      second = tool(fixture.tools, "mcp_list_tools").execute("second", { serverId: "queue" }, controller.signal, undefined, {} as never);
-      void second.catch((error: unknown) => {
-        secondOutcome = error;
-      });
-      controller.abort(new Error("queued request cancelled"));
-      await vi.waitFor(() => expect(secondOutcome).toBeInstanceOf(Error), { timeout: 500 });
-      expect((secondOutcome as Error).message).toMatch(/cancelled/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-      await first.catch(() => undefined);
-      await second?.catch(() => undefined);
-    }
-  });
-
-  test("retains stdout framing bytes between managed requests", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = "";
-const notification = JSON.stringify({ jsonrpc: "2.0", method: "notifications/message", params: { data: "between requests" } });
-const split = Math.floor(notification.length / 2);
-const header = "Content-Length: " + Buffer.byteLength(notification) + "\\r\\n\\r\\n";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "framing", version: "1" } } }) + "\\n" + header + notification.slice(0, split)); else if (message.method === "tools/list") process.stdout.write(notification.slice(split) + JSON.stringify({ jsonrpc: "2.0", id: message.id, result: { tools: [{ name: "retained", inputSchema: { type: "object" } }] } }) + "\\n"); } });`,
-    );
-    try {
-      await tool(fixture.tools, "mcp_server_start").execute(
-        "start-framing",
-        { command: [process.execPath, server], serverId: "framing" },
-        undefined,
-        undefined,
-        {} as never,
-      );
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("list-framing", { serverId: "framing" }, AbortSignal.timeout(500), undefined, {} as never),
-      ).resolves.toMatchObject({ details: { tools: [{ name: "retained" }] } });
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("bounds total bytes received before the matching response", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "bytes", version: "1" } } }); else if (message.method === "tools/list") { for (let index = 0; index < 1400; index += 1) send({ jsonrpc: "2.0", method: "notifications/message", params: { data: "x".repeat(900) } }); send({ jsonrpc: "2.0", id: message.id, result: { tools: [] } }); } } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("total-bytes", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/response exceeded the 1 MiB limit/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects remote inventories above the item limit", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "inventory-limit", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: Array.from({ length: 1001 }, (_, index) => ({ name: "tool-" + index, inputSchema: { type: "object" } })) } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("inventory-limit", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/inventory.*1000 items/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects malformed remote tool descriptors", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "malformed-tool", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: [{ name: "", description: 42, inputSchema: [] }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("malformed-tool", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/invalid MCP tool descriptor/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects malformed remote resource and prompt descriptors", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "malformed-inventory", version: "1" } } }); else if (message.method === "resources/list") send({ jsonrpc: "2.0", id: message.id, result: { resources: [{ uri: "fixture://missing-name" }] } }); else if (message.method === "prompts/list") send({ jsonrpc: "2.0", id: message.id, result: { prompts: [{ name: "", arguments: {} }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_resources").execute("malformed-resource", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/invalid MCP resource descriptor/iu);
-      await expect(
-        tool(fixture.tools, "mcp_list_prompts").execute("malformed-prompt", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/invalid MCP prompt descriptor/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects malformed MCP tool result content before returning it to the agent", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "malformed-result", version: "1" } } }); else if (message.method === "tools/call") send({ jsonrpc: "2.0", id: message.id, result: { content: [{ type: "text", text: 42 }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "malformed-result",
-          { command: [process.execPath, server], name: "echo", arguments: {} },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/invalid MCP tool result content/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects malformed base64 content before returning it to the agent", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "malformed-base64", version: "1" } } }); else if (message.method === "tools/call") send({ jsonrpc: "2.0", id: message.id, result: { content: [{ type: "image", data: "not-base64!", mimeType: "image/png" }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute("malformed-base64", { command: [process.execPath, server], name: "image" }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/invalid MCP tool result content/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("does not publish an invalid MCP tool call as the latest successful call", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "invalid-call-state", version: "1" } } }); else if (message.method === "tools/call") send({ jsonrpc: "2.0", id: message.id, result: { content: [{ type: "text", text: 42 }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "invalid-call-state",
-          { command: [process.execPath, server], name: "broken" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/invalid MCP tool result content/iu);
-      await expect(fixture.panels.snapshot()).resolves.toMatchObject([{ data: { lastCall: null } }]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("normalizes resource and prompt payloads into agent text and image content", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "content", version: "1" } } }); else if (message.method === "resources/read") send({ jsonrpc: "2.0", id: message.id, result: { contents: [{ uri: message.params.uri, mimeType: "text/plain", text: "resource body" }, { uri: "fixture://image", mimeType: "image/png", blob: "aGVsbG8=" }] } }); else if (message.method === "prompts/get") send({ jsonrpc: "2.0", id: message.id, result: { description: "Review", messages: [{ role: "user", content: { type: "text", text: "Review this" } }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_read_resource").execute(
-          "read-resource",
-          { command: [process.execPath, server], uri: "fixture://readme" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).resolves.toMatchObject({
-        content: [
-          { type: "text", text: "resource body" },
-          { type: "image", data: "aGVsbG8=", mimeType: "image/png" },
-        ],
-      });
-      await expect(
-        tool(fixture.tools, "mcp_get_prompt").execute("get-prompt", { command: [process.execPath, server], name: "review" }, undefined, undefined, {} as never),
-      ).resolves.toMatchObject({ content: [{ type: "text", text: "[user]\nReview this" }] });
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("accepts spec-valid binary resources without an optional MIME type", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "optional-mime", version: "1" } } }); else if (message.method === "resources/read") send({ jsonrpc: "2.0", id: message.id, result: { contents: [{ uri: "fixture://binary", blob: "aGVsbG8=" }] } }); else if (message.method === "tools/call") send({ jsonrpc: "2.0", id: message.id, result: { content: [{ type: "resource", resource: { uri: "fixture://embedded", blob: "aGVsbG8=" } }] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_read_resource").execute(
-          "optional-mime-read",
-          { command: [process.execPath, server], uri: "fixture://binary" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).resolves.toMatchObject({ content: [{ type: "text", text: "[MCP binary resource omitted: fixture://binary (unknown MIME type)]" }] });
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "optional-mime-call",
-          { command: [process.execPath, server], name: "binary" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).resolves.toMatchObject({ content: [{ type: "text", text: "[MCP binary resource omitted: fixture://embedded (unknown MIME type)]" }] });
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("does not mix inventories from different MCP servers", async () => {
-    const fixture = await createFixture();
-    const resourceServer = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "resources", version: "1" } } }); else if (message.method === "resources/list") send({ jsonrpc: "2.0", id: message.id, result: { resources: [{ uri: "fixture://one", name: "One" }] } }); } });`,
-    );
-    const toolServer = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "tools", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: [{ name: "echo", inputSchema: { type: "object" } }] } }); } });`,
-    );
-    try {
-      await tool(fixture.tools, "mcp_list_resources").execute("resources", { command: [process.execPath, resourceServer] }, undefined, undefined, {} as never);
-      await tool(fixture.tools, "mcp_list_tools").execute("tools", { command: [process.execPath, toolServer] }, undefined, undefined, {} as never);
-      await expect(fixture.panels.snapshot()).resolves.toMatchObject([{ data: { resources: [], tools: [{ name: "echo" }] } }]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects NUL command arguments and invalid server ids before spawning", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "validation", version: "1" } } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("nul-command", { command: [process.execPath, `bad\0argument`] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/command.*NUL/iu);
-      await expect(
-        tool(fixture.tools, "mcp_server_start").execute(
-          "invalid-id",
-          { command: [process.execPath, server], serverId: "bad id" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/serverId.*letters.*numbers/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("validates tool names, prompt names, and resource URIs before spawning", async () => {
-    const fixture = await createFixture();
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_call").execute(
-          "invalid-tool-name",
-          { command: ["/definitely/missing-mcp-server"], name: "" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/tool name.*1.*512/iu);
-      await expect(
-        tool(fixture.tools, "mcp_get_prompt").execute(
-          "invalid-prompt-name",
-          { command: ["/definitely/missing-mcp-server"], name: "bad\0name" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/prompt name.*NUL/iu);
-      await expect(
-        tool(fixture.tools, "mcp_read_resource").execute(
-          "invalid-uri",
-          { command: ["/definitely/missing-mcp-server"], uri: "bad\0uri" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/resource URI.*NUL/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("escalates to SIGKILL when a one-shot server ignores graceful shutdown", async () => {
-    if (process.platform === "win32") return;
-    const fixture = await createFixture();
-    const pidPath = join(fixture.cwd, "server.pid");
-    const requested = join(fixture.cwd, "kill-requested");
-    const server = await writeServer(
-      fixture.cwd,
-      `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(pidPath)}, String(process.pid)); process.on("SIGTERM", () => {}); setInterval(() => {}, 1000); let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "ignore-term", version: "1" } } }); else if (message.method === "tools/list") writeFileSync(${JSON.stringify(requested)}, "yes"); } });`,
-    );
-    const pending = tool(fixture.tools, "mcp_list_tools").execute("kill-fallback", { command: [process.execPath, server] }, undefined, undefined, {} as never);
-    void pending.catch(() => undefined);
-    let pid: number | undefined;
-    try {
-      await vi.waitFor(() => expect(existsSync(requested)).toBe(true));
-      pid = Number(await readFile(pidPath, "utf8"));
-      await fixture.context.fiber.dispose();
-      await pending.catch(() => undefined);
-      await vi.waitFor(
-        () => {
-          expect(() => process.kill(pid!, 0)).toThrow();
-        },
-        { timeout: 1500 },
-      );
-    } finally {
-      if (pid !== undefined) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-          // The plugin already reaped the process.
-        }
-      }
-      await fixture.context.fiber.dispose();
-      await pending.catch(() => undefined);
-    }
-  });
-
-  test("cancels a stop request while an earlier managed request is still running", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-mcp-client-stop-"));
-    temporaryDirectories.push(cwd);
-    const requested = join(cwd, "stop-wait-requested");
-    const server = await writeServer(
-      cwd,
-      `import { writeFileSync } from "node:fs"; let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "stop-wait", version: "1" } } }); else if (message.method === "tools/list") writeFileSync(${JSON.stringify(requested)}, "yes"); } });`,
-    );
-    const fixture = await createFixture({ servers: [{ id: "stop-wait", command: [process.execPath, server] }] });
-    await tool(fixture.tools, "mcp_server_start").execute("start", { serverId: "stop-wait" }, undefined, undefined, {} as never);
-    const first = tool(fixture.tools, "mcp_list_tools").execute("list", { serverId: "stop-wait" }, undefined, undefined, {} as never);
-    void first.catch(() => undefined);
-    const controller = new AbortController();
-    let stopOutcome: unknown;
-    let stopping: Promise<unknown> | undefined;
-    try {
-      await vi.waitFor(() => expect(existsSync(requested)).toBe(true));
-      stopping = tool(fixture.tools, "mcp_server_stop").execute("stop", { serverId: "stop-wait" }, controller.signal, undefined, {} as never);
-      void stopping.catch((error: unknown) => {
-        stopOutcome = error;
-      });
-      controller.abort(new Error("stop cancelled"));
-      await vi.waitFor(() => expect(stopOutcome).toBeInstanceOf(Error), { timeout: 500 });
-      expect((stopOutcome as Error).message).toMatch(/cancelled/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-      await first.catch(() => undefined);
-      await stopping?.catch(() => undefined);
-    }
-  });
-
-  test("bounds captured server stderr by UTF-8 bytes", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `process.stderr.write("🙂".repeat(5000)); let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; const newline = buffer.indexOf("\\n"); if (newline < 0) return; const message = JSON.parse(buffer.slice(0, newline)); send({ jsonrpc: "2.0", id: message.id, error: { code: -32000, message: "boom" } }); });`,
-    );
-    let failure: unknown;
-    try {
-      await tool(fixture.tools, "mcp_list_tools")
-        .execute("stderr", { command: [process.execPath, server] }, undefined, undefined, {} as never)
-        .catch((error: unknown) => {
-          failure = error;
-        });
-      expect(failure).toBeInstanceOf(Error);
-      expect(Buffer.byteLength((failure as Error).message, "utf8")).toBeLessThanOrEqual(8300);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects invalid UTF-8 in MCP JSON frames", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "utf8", version: "1" } } }); else if (message.method === "tools/list") process.stdout.write(Buffer.concat([Buffer.from('{"jsonrpc":"2.0","id":' + message.id + ',"result":{"tools":[{"name":"'), Buffer.from([0xc3, 0x28]), Buffer.from('","inputSchema":{"type":"object"}}]}}\\n')])); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("invalid-utf8", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/valid UTF-8/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects malformed JSON-RPC response envelopes", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "rpc", version: "1" } } }); else if (message.method === "tools/list") send({ id: message.id, result: { tools: [] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("invalid-rpc", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/invalid JSON-RPC response/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects an invalid initialize result before sending initialized", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "unsupported", capabilities: [], serverInfo: { name: "", version: 1 } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: [] } }); } });`,
-    );
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute("invalid-initialize", { command: [process.execPath, server] }, undefined, undefined, {} as never),
-      ).rejects.toThrow(/invalid MCP initialize result/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("detaches resource and prompt details from panel state", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "detach", version: "1" } } }); else if (message.method === "resources/list") send({ jsonrpc: "2.0", id: message.id, result: { resources: [{ uri: "fixture://original", name: "Original" }] } }); else if (message.method === "prompts/list") send({ jsonrpc: "2.0", id: message.id, result: { prompts: [{ name: "original", arguments: [] }] } }); } });`,
-    );
-    try {
-      const resourcesResult = await tool(fixture.tools, "mcp_list_resources").execute(
-        "resources",
-        { command: [process.execPath, server] },
-        undefined,
-        undefined,
-        {} as never,
-      );
-      (resourcesResult.details as { resources: Array<{ uri: string }> }).resources[0]!.uri = "fixture://mutated";
-      await expect(fixture.panels.snapshot()).resolves.toMatchObject([{ data: { resources: [{ uri: "fixture://original" }] } }]);
-      const promptsResult = await tool(fixture.tools, "mcp_list_prompts").execute(
-        "prompts",
-        { command: [process.execPath, server] },
-        undefined,
-        undefined,
-        {} as never,
-      );
-      (promptsResult.details as { prompts: Array<{ name: string }> }).prompts[0]!.name = "mutated";
-      await expect(fixture.panels.snapshot()).resolves.toMatchObject([{ data: { prompts: [{ name: "original" }] } }]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("detaches managed server command snapshots from tool results", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "snapshot", version: "1" } } }); } });`,
-    );
-    try {
-      const started = await tool(fixture.tools, "mcp_server_start").execute(
-        "start",
-        { command: [process.execPath, server], serverId: "snapshot" },
-        undefined,
-        undefined,
-        {} as never,
-      );
-      (started.details as { command: string[] }).command[0] = "mutated";
-      const status = await tool(fixture.tools, "mcp_server_status").execute("status", {}, undefined, undefined, {} as never);
-      expect((status.details as { servers: Array<{ executable: string }> }).servers[0]?.executable).toBe(process.execPath.split("/").pop());
-      (status.details as { servers: Array<{ executable: string }> }).servers[0]!.executable = "mutated-again";
-      const secondStatus = await tool(fixture.tools, "mcp_server_status").execute("status-again", {}, undefined, undefined, {} as never);
-      expect((secondStatus.details as { servers: Array<{ executable: string }> }).servers[0]?.executable).toBe(process.execPath.split("/").pop());
-      await expect(fixture.panels.snapshot()).resolves.toMatchObject([
-        { data: { servers: [{ id: "snapshot", executable: process.execPath.split("/").pop(), argumentCount: 1, status: "running" }] } },
-      ]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("reserves managed server ids while concurrent starts initialize", async () => {
-    const fixture = await createFixture();
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") setTimeout(() => send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "concurrent", version: "1" } } }), 100); } });`,
-    );
-    try {
-      const starts = await Promise.allSettled([
-        tool(fixture.tools, "mcp_server_start").execute(
-          "start-1",
-          { command: [process.execPath, server], serverId: "same" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-        tool(fixture.tools, "mcp_server_start").execute(
-          "start-2",
-          { command: [process.execPath, server], serverId: "same" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ]);
-      expect(starts.filter((result) => result.status === "fulfilled")).toHaveLength(1);
-      expect(starts.filter((result) => result.status === "rejected")).toHaveLength(1);
-      const rejection = starts.find((result) => result.status === "rejected");
-      expect(rejection?.status).toBe("rejected");
-      const reason: unknown = rejection?.status === "rejected" ? (rejection.reason as unknown) : undefined;
-      expect(reason).toBeInstanceOf(Error);
-      expect((reason as Error).message).toMatch(/already.*starting|already running/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("releases a managed server id when process spawning throws synchronously", async () => {
-    const fixture = await createFixture({ launchCwd: "invalid\0cwd" });
-    try {
-      const start = () =>
-        tool(fixture.tools, "mcp_server_start").execute(
-          "sync-spawn-failure",
-          { command: [process.execPath, "server.mjs"], serverId: "retryable" },
-          undefined,
-          undefined,
-          {} as never,
-        );
-      await expect(start()).rejects.toThrow(/null bytes|must be a string without null bytes|invalid.*cwd/iu);
-      await expect(start()).rejects.toThrow(/null bytes|must be a string without null bytes|invalid.*cwd/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("does not expose command arguments in the plugin panel", async () => {
-    const secret = "secret-command-argument";
-    const fixture = await createFixture({ servers: [{ id: "private", command: [process.execPath, secret] }] });
-    try {
-      const panels = await fixture.panels.snapshot();
-      expect(JSON.stringify(panels)).not.toContain(secret);
-      expect(panels).toMatchObject([
-        {
-          data: {
-            servers: [{ id: "private", executable: process.execPath.split("/").pop(), argumentCount: 1, status: "stopped" }],
-          },
-        },
-      ]);
-      const status = await tool(fixture.tools, "mcp_server_status").execute("status", {}, undefined, undefined, {} as never);
-      expect(JSON.stringify(status)).not.toContain(secret);
-      expect(status).toMatchObject({ details: { servers: [{ id: "private", executable: process.execPath.split("/").pop(), argumentCount: 1 }] } });
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("does not expose one-shot command arguments as the latest server label", async () => {
-    const fixture = await createFixture();
-    const secret = "secret-one-shot-argument";
-    const server = await writeServer(
-      fixture.cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "private", version: "1" } } }); else if (message.method === "tools/list") send({ jsonrpc: "2.0", id: message.id, result: { tools: [] } }); } });`,
-    );
-    try {
-      await tool(fixture.tools, "mcp_list_tools").execute("private", { command: [process.execPath, server, secret] }, undefined, undefined, {} as never);
-      const panels = await fixture.panels.snapshot();
-      expect(JSON.stringify(panels)).not.toContain(secret);
-      expect(panels).toMatchObject([{ data: { server: `${process.execPath.split("/").pop()} (+2 args)` } }]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("accepts only string values for MCP prompt arguments", async () => {
-    const fixture = await createFixture();
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_get_prompt").execute(
-          "prompt-arguments",
-          { command: ["/definitely/missing-mcp-server"], name: "review", arguments: { count: 2 } },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/prompt arguments.*string values/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects oversized configured server inventories", async () => {
-    let fixture: Awaited<ReturnType<typeof createFixture>> | undefined;
-    let failure: unknown;
-    try {
-      fixture = await createFixture({
-        servers: Array.from({ length: 129 }, (_, index) => ({ id: `server-${index}`, command: [process.execPath, "server.mjs"] })),
-      });
-    } catch (error) {
-      failure = error;
-    } finally {
-      await fixture?.context.fiber.dispose();
-    }
-    expect(failure).toBeInstanceOf(Error);
-    expect((failure as Error).message).toMatch(/configured.*128 servers/iu);
-  });
-
-  test("does not allocate an automatic id reserved by configuration", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-mcp-client-id-"));
-    temporaryDirectories.push(cwd);
-    const configuredServer = await writeServer(cwd, `process.stdin.resume();`);
-    const directServer = await writeServer(
-      cwd,
-      `let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "direct", version: "1" } } }); } });`,
-    );
-    const fixture = await createFixture({ servers: [{ id: "mcp-1", command: [process.execPath, configuredServer] }] });
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_server_start").execute("automatic-id", { command: [process.execPath, directServer] }, undefined, undefined, {} as never),
-      ).resolves.toMatchObject({ details: { serverId: "mcp-2" } });
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("rejects ambiguous one-shot and managed server targets", async () => {
-    const fixture = await createFixture();
-    try {
-      await expect(
-        tool(fixture.tools, "mcp_list_tools").execute(
-          "ambiguous-target",
-          { command: [process.execPath, "server.mjs"], serverId: "configured" },
-          undefined,
-          undefined,
-          {} as never,
-        ),
-      ).rejects.toThrow(/either command or serverId, not both/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("reports truncated managed server inventory in the panel", async () => {
-    const fixture = await createFixture({
-      servers: Array.from({ length: 25 }, (_, index) => ({ id: `server-${index}`, command: [process.execPath, "server.mjs"] })),
-    });
-    try {
-      const panels = await fixture.panels.snapshot();
-      expect((panels[0]?.data as { servers: unknown[] }).servers).toHaveLength(20);
-      expect(panels).toMatchObject([{ data: { inventory: { servers: { total: 25, shown: 20, truncated: true } } } }]);
-    } finally {
-      await fixture.context.fiber.dispose();
-    }
-  });
-
-  test("stops a managed server without waiting for an in-flight request timeout", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "pi-harness-mcp-client-fast-stop-"));
-    temporaryDirectories.push(cwd);
-    const requested = join(cwd, "fast-stop-requested");
-    const server = await writeServer(
-      cwd,
-      `import { writeFileSync } from "node:fs"; let buffer = ""; const send = (value) => process.stdout.write(JSON.stringify(value) + "\\n"); process.stdin.setEncoding("utf8"); process.stdin.on("data", (chunk) => { buffer += chunk; for (;;) { const newline = buffer.indexOf("\\n"); if (newline < 0) break; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line.trim()) continue; const message = JSON.parse(line); if (message.method === "initialize") send({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: {}, serverInfo: { name: "fast-stop", version: "1" } } }); else if (message.method === "tools/list") writeFileSync(${JSON.stringify(requested)}, "yes"); } });`,
-    );
-    const fixture = await createFixture({ servers: [{ id: "fast-stop", command: [process.execPath, server] }] });
-    await tool(fixture.tools, "mcp_server_start").execute("start", { serverId: "fast-stop" }, undefined, undefined, {} as never);
-    const pending = tool(fixture.tools, "mcp_list_tools").execute("list", { serverId: "fast-stop" }, undefined, undefined, {} as never);
-    void pending.catch(() => undefined);
-    let stopped: unknown;
-    let stopping: Promise<unknown> | undefined;
-    try {
-      await vi.waitFor(() => expect(existsSync(requested)).toBe(true));
-      stopping = tool(fixture.tools, "mcp_server_stop")
-        .execute("stop", { serverId: "fast-stop" }, undefined, undefined, {} as never)
-        .then((result) => {
-          stopped = result;
-        });
-      void stopping.catch(() => undefined);
-      await vi.waitFor(() => expect(stopped).toMatchObject({ details: { stopped: true } }), { timeout: 500 });
-      await expect(pending).rejects.toThrow(/stopped/iu);
-    } finally {
-      await fixture.context.fiber.dispose();
-      await pending.catch(() => undefined);
-      await stopping?.catch(() => undefined);
-    }
-  });
-});