@wrongstack/acp 0.274.0 → 0.275.1

package/dist/index.js

@@ -1,9 +1,10 @@
 import { writeErr, expectDefined } from '@wrongstack/core';
 import { fileURLToPath } from 'url';
+import { createServer } from 'http';
+import { SubagentBudget } from '@wrongstack/core/coordination';
 import * as fsp from 'fs/promises';
 import * as path from 'path';
 import { spawn } from 'child_process';
-import { SubagentBudget } from '@wrongstack/core/coordination';
 
 // src/agent/stdio-transport.ts
 var StdioTransport = class {
@@ -110,9 +111,10 @@ var ClientTransport = class {
   }
   async start() {
     if (this.child) return;
-    const [{ spawn: spawn3 }, { buildChildEnv }] = await Promise.all([
+    const [{ spawn: spawn3 }, { buildChildEnv }, os] = await Promise.all([
       import('child_process'),
-      import('@wrongstack/core')
+      import('@wrongstack/core'),
+      import('os')
     ]);
     return new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
@@ -120,10 +122,12 @@ var ClientTransport = class {
           new Error(`ACP child process failed to start within ${this.opts.handshakeTimeoutMs}ms`)
         );
       }, this.opts.handshakeTimeoutMs);
+      const isPkgLauncher = this.opts.command === "npx" || this.opts.command === "uvx";
+      const spawnCwd = isPkgLauncher ? os.homedir() : this.opts.cwd;
       try {
         this.child = spawn3(this.opts.command, this.opts.args ?? [], {
           env: { ...buildChildEnv(), ...this.opts.env },
-          cwd: this.opts.cwd,
+          cwd: spawnCwd,
           stdio: ["pipe", "pipe", "pipe"],
           windowsHide: true,
           // On Windows, most ACP-supporting tools (claude, gemini, codex,
@@ -142,17 +146,39 @@ var ClientTransport = class {
       }
       const child = this.child;
       child.stdout.setEncoding("utf8");
+      let settled = false;
+      const onSpawnFailure = (err) => {
+        if (settled) {
+          this.closed = true;
+          return;
+        }
+        settled = true;
+        clearTimeout(timeout);
+        reject(err);
+      };
+      child.on("error", onSpawnFailure);
+      child.stdout.on("error", onSpawnFailure);
+      if (this.opts.skipHandshakeMarker) {
+        child.stdout.on("data", (c) => this.onChildData(c));
+        child.stderr.on("data", (c) => this.onChildError(c));
+        child.on("close", (code) => this.onChildClose(code));
+        child.once("spawn", () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeout);
+          resolve3();
+        });
+        return;
+      }
       const onReady = () => {
+        if (settled) return;
+        settled = true;
         child.stdout.on("data", (c) => this.onChildData(c));
         child.stderr.on("data", (c) => this.onChildError(c));
         child.on("close", (code) => this.onChildClose(code));
         clearTimeout(timeout);
         resolve3();
       };
-      if (this.opts.skipHandshakeMarker) {
-        onReady();
-        return;
-      }
       const waitForMarker = (chunk) => {
         this.buffer += chunk;
         const idx = this.buffer.indexOf("[wstack-acp]\n");
@@ -163,14 +189,6 @@ var ClientTransport = class {
         }
       };
       child.stdout.on("data", waitForMarker);
-      child.stdout.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-      child.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
     });
   }
   send(msg) {
@@ -365,7 +383,16 @@ var ACP_PROTOCOL_VERSION = 1;
 function toWire(msg) {
   return msg;
 }
-var WRONGSTACK_VERSION = "0.263.0";
+var WRONGSTACK_VERSION = "0.274.1";
+var WRONGSTACK_AUTH_METHODS = [
+  {
+    id: "wrongstack-auth",
+    name: "Run wstack auth",
+    description: "Configure a WrongStack model provider in an interactive terminal.",
+    type: "terminal",
+    args: ["auth"]
+  }
+];
 var DEFAULT_MODE_ID = "code";
 var DEFAULT_MODES = [
   {
@@ -382,9 +409,17 @@ var ACPProtocolHandler = class {
   modes;
   configOptions;
   agentName;
+  replayFor;
+  seedFor;
+  store;
   initialized = false;
+  clientCapabilities = {};
   sessions = /* @__PURE__ */ new Map();
   nextId = 1;
+  // Outbound request correlation (server → client requests, e.g.
+  // session/request_permission). Keyed by our own `srv_N` ids.
+  pendingOut = /* @__PURE__ */ new Map();
+  nextOutId = 1;
   constructor(opts) {
     this.transport = opts.transport;
     this.defaultCwd = opts.defaultCwd;
@@ -394,6 +429,43 @@ var ACPProtocolHandler = class {
     this.modes = opts.modes ?? DEFAULT_MODES;
     this.configOptions = opts.configOptions ?? [];
     this.agentName = opts.agentName ?? "wrongstack";
+    this.replayFor = opts.replayFor;
+    this.seedFor = opts.seedFor;
+    this.store = opts.store;
+    if (typeof this.transport.onMessage === "function") {
+      this.transport.onMessage((m) => this.maybeResolvePending(m));
+    }
+  }
+  /**
+   * Send a request to the client and await its response. Used for
+   * server-initiated calls like `session/request_permission`. Rejects on
+   * timeout or transport error so the caller can pick a safe fallback.
+   */
+  request(method, params, timeoutMs = 6e4) {
+    const id = `srv_${this.nextOutId++}`;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingOut.delete(id);
+        reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingOut.set(id, { resolve: resolve3, reject, timer });
+      this.transport.send(toWire({ jsonrpc: "2.0", id, method, params })).catch((e) => {
+        clearTimeout(timer);
+        this.pendingOut.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      });
+    });
+  }
+  maybeResolvePending(m) {
+    const id = m.id;
+    if (typeof id !== "string") return;
+    const pending = this.pendingOut.get(id);
+    if (!pending) return;
+    this.pendingOut.delete(id);
+    clearTimeout(pending.timer);
+    const err = m.error;
+    if (err) pending.reject(new Error(err.message ?? "client request failed"));
+    else pending.resolve(m.result);
   }
   /**
    * Process one inbound message. Returns true if this was a terminal
@@ -420,6 +492,11 @@ var ACPProtocolHandler = class {
       session.abort.abort();
     }
     this.sessions.clear();
+    for (const [, p] of this.pendingOut) {
+      clearTimeout(p.timer);
+      p.reject(new Error("protocol handler closed"));
+    }
+    this.pendingOut.clear();
   }
   // ────────────────────────────────────────────────────────────────────
   // Requests
@@ -435,10 +512,18 @@ var ACPProtocolHandler = class {
           return await this.handleInitialize(id, params);
         case "authenticate":
           return await this.handleAuthenticate(id, params);
+        case "logout":
+          return await this.handleLogout(id, params);
         case "session/new":
           return await this.handleSessionNew(id, params);
         case "session/load":
           return await this.handleSessionLoad(id, params);
+        case "session/resume":
+          return await this.handleSessionResume(id, params);
+        case "session/close":
+          return await this.handleSessionClose(id, params);
+        case "session/delete":
+          return await this.handleSessionDelete(id, params);
         case "session/prompt":
           return await this.handleSessionPrompt(id, params);
         case "session/set_mode":
@@ -447,6 +532,16 @@ var ACPProtocolHandler = class {
           return await this.handleSetConfigOption(id, params);
         case "session/list":
           return await this.handleSessionList(id);
+        case "session/fork":
+          return await this.handleSessionFork(id, params);
+        case "providers/list":
+          return await this.handleProvidersList(id, params);
+        case "providers/set":
+          return await this.handleProvidersSet(id, params);
+        case "providers/disable":
+          return await this.handleProvidersDisable(id, params);
+        case "mcp/message":
+          return await this.handleMcpMessage(id, params);
         default:
           await this.sendError(id, -32601, `Unknown method: ${method}`);
           return false;
@@ -459,14 +554,8 @@ var ACPProtocolHandler = class {
   }
   async handleInitialize(id, params) {
     const p = params ?? {};
-    const requested = typeof p.protocolVersion === "number" ? p.protocolVersion : 1;
-    if (requested !== ACP_PROTOCOL_VERSION) {
-      await this.sendError(
-        id,
-        -32e3,
-        `server speaks protocolVersion=${ACP_PROTOCOL_VERSION}, client requested ${requested}`
-      );
-      return false;
+    if (p.clientCapabilities && typeof p.clientCapabilities === "object") {
+      this.clientCapabilities = p.clientCapabilities;
     }
     this.initialized = true;
     await this.transport.send(toWire({
@@ -477,9 +566,25 @@ var ACPProtocolHandler = class {
         agentCapabilities: {
           loadSession: true,
           promptCapabilities: {
-            image: false,
+            // We route ACP image blocks into the core agent's multimodal
+            // input (server-agent-turn.promptToAgentInput); whether the
+            // model can see them is the configured provider's concern.
+            image: true,
             audio: false,
             embeddedContext: true
+          },
+          mcpCapabilities: {
+            http: false,
+            sse: false
+          },
+          sessionCapabilities: {
+            close: {},
+            list: {},
+            delete: {},
+            resume: {}
+          },
+          auth: {
+            logout: {}
           }
         },
         agentInfo: {
@@ -487,10 +592,7 @@ var ACPProtocolHandler = class {
           title: "WrongStack",
           version: WRONGSTACK_VERSION
         },
-        // Static options advertised at handshake. They are also
-        // re-sent on every `current_mode_update` / `config_option_update`
-        // notification so late-joining clients see them.
-        authMethods: [],
+        authMethods: WRONGSTACK_AUTH_METHODS,
         modes: this.modes,
         configOptions: this.configOptions
       }
@@ -505,6 +607,14 @@ var ACPProtocolHandler = class {
     }));
     return false;
   }
+  async handleLogout(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
   async handleSessionNew(id, params) {
     const p = params ?? {};
     const cwd = typeof p.cwd === "string" ? p.cwd : this.defaultCwd;
@@ -520,6 +630,7 @@ var ACPProtocolHandler = class {
     };
     this.sessions.set(sessionId, state);
     this.onSessionNew(state);
+    await this.persist(state);
     await this.sendNotification({
       sessionId,
       update: {
@@ -548,7 +659,173 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleSessionLoad(id, params) {
-    return this.handleSessionNew(id, params);
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
+    let existing = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!existing && sessionId && this.store) {
+      const persisted = await this.store.load(sessionId);
+      if (persisted) {
+        const restored = {
+          id: sessionId,
+          cwd: persisted.cwd ?? loadCwd ?? this.defaultCwd,
+          abort: new AbortController(),
+          modeId: persisted.modeId ?? DEFAULT_MODE_ID,
+          createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...persisted.title !== void 0 ? { title: persisted.title } : {}
+        };
+        this.sessions.set(sessionId, restored);
+        this.seedFor?.(sessionId, persisted.history ?? []);
+        for (const update of persisted.history ?? []) {
+          await this.sendNotification({ sessionId, update });
+        }
+        await this.sendNotification({
+          sessionId,
+          update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
+        });
+        await this.transport.send(toWire({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            initialMode: { currentModeId: restored.modeId, availableModes: this.modes }
+          }
+        }));
+        return false;
+      }
+    }
+    if (existing) {
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const replay = sessionId ? this.replayFor?.(sessionId) : void 0;
+      if (replay) {
+        for (const update of replay) {
+          await this.sendNotification({ sessionId, update });
+        }
+      }
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          updatedAt: existing.updatedAt
+        }
+      });
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "current_mode_update",
+          modeId: existing.modeId
+        }
+      });
+      await this.transport.send(toWire({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          initialMode: {
+            currentModeId: existing.modeId,
+            availableModes: this.modes
+          }
+        }
+      }));
+      return false;
+    }
+    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+    return false;
+  }
+  async handleSessionResume(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const existing = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (existing) {
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.transport.send(toWire({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          initialMode: {
+            currentModeId: existing.modeId,
+            availableModes: this.modes
+          }
+        }
+      }));
+      return false;
+    }
+    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+    return false;
+  }
+  async handleSessionClose(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const session = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!session) {
+      await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+      return false;
+    }
+    session.abort.abort();
+    if (sessionId) this.sessions.delete(sessionId);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleSessionDelete(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sessionId) {
+      await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+      return false;
+    }
+    if (!this.sessions.has(sessionId)) {
+      await this.transport.send(toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } }));
+      return false;
+    }
+    const session = this.sessions.get(sessionId);
+    session.abort.abort();
+    this.sessions.delete(sessionId);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleSessionFork(id, params) {
+    const p = params ?? {};
+    const sourceId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sourceId || !this.sessions.has(sourceId)) {
+      await this.sendError(id, -32e3, `session not found: ${sourceId}`);
+      return false;
+    }
+    const forkParams = params;
+    return this.handleSessionNew(id, { ...forkParams, cwd: p.cwd ?? this.defaultCwd });
+  }
+  async handleProvidersList(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        providers: [],
+        currentProviderId: null
+      }
+    }));
+    return false;
+  }
+  async handleProvidersSet(id, _params) {
+    await this.sendError(id, -32e3, "provider configuration not available through ACP; use wstack auth");
+    return false;
+  }
+  async handleProvidersDisable(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleMcpMessage(id, _params) {
+    await this.sendError(id, -32e3, "MCP message routing not available through ACP");
+    return false;
   }
   async handleSessionPrompt(id, params) {
     const p = params ?? {};
@@ -568,11 +845,54 @@ var ACPProtocolHandler = class {
     const turnSignal = new AbortController();
     const onCancel = () => turnSignal.abort();
     session.abort.signal.addEventListener("abort", onCancel, { once: true });
+    const api = {
+      clientCapabilities: this.clientCapabilities,
+      requestPermission: async (req) => {
+        const res = await this.request("session/request_permission", {
+          sessionId,
+          toolCall: req.toolCall,
+          options: req.options
+        });
+        const outcome = res?.outcome;
+        return outcome ?? { outcome: "cancelled" };
+      },
+      readTextFile: async (params2) => {
+        const res = await this.request("fs/read_text_file", { sessionId, ...params2 });
+        return String(res?.content ?? "");
+      },
+      writeTextFile: async (params2) => {
+        await this.request("fs/write_text_file", { sessionId, ...params2 });
+      },
+      runTerminal: async ({ command, args, cwd }) => {
+        const created = await this.request("terminal/create", {
+          sessionId,
+          command,
+          ...args ? { args } : {},
+          ...cwd ? { cwd } : {}
+        });
+        const terminalId = created?.terminalId;
+        if (!terminalId) return { output: "", exitCode: null };
+        try {
+          const exit = await this.request("terminal/wait_for_exit", { sessionId, terminalId });
+          const out = await this.request("terminal/output", { sessionId, terminalId });
+          return {
+            output: String(out?.output ?? ""),
+            exitCode: typeof exit?.exitCode === "number" ? exit.exitCode : null
+          };
+        } finally {
+          try {
+            await this.request("terminal/release", { sessionId, terminalId });
+          } catch {
+          }
+        }
+      }
+    };
     let result;
     try {
       result = await this.runTurn(
         { sessionId, prompt: p.prompt, signal: turnSignal.signal },
-        (update) => this.sendNotification({ sessionId, update })
+        (update) => this.sendNotification({ sessionId, update }),
+        api
       );
     } catch (err) {
       session.abort.signal.removeEventListener("abort", onCancel);
@@ -582,6 +902,7 @@ var ACPProtocolHandler = class {
     }
     session.abort.signal.removeEventListener("abort", onCancel);
     session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persist(session);
     await this.transport.send(toWire({
       jsonrpc: "2.0",
       id,
@@ -610,12 +931,12 @@ var ACPProtocolHandler = class {
   async handleSetConfigOption(id, params) {
     const p = params ?? {};
     const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const optionId = typeof p.configOptionId === "string" ? p.configOptionId : null;
+    const optionId = typeof p.configId === "string" ? p.configId : null;
     const value = typeof p.value === "string" ? p.value : null;
     const session = sessionId ? this.sessions.get(sessionId) : void 0;
     const option = optionId ? this.configOptions.find((o) => o.id === optionId) : void 0;
     if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
-      await this.sendError(id, -32602, "invalid sessionId, configOptionId, or value");
+      await this.sendError(id, -32602, "invalid sessionId, configId, or value");
       return false;
     }
     option.currentValue = value;
@@ -627,7 +948,7 @@ var ACPProtocolHandler = class {
         configOptions: [...this.configOptions]
       }
     });
-    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } }));
     return false;
   }
   async handleSessionList(id) {
@@ -661,6 +982,9 @@ var ACPProtocolHandler = class {
         }
         return false;
       }
+      case "$/cancel_request": {
+        return false;
+      }
       case "exit":
         this.close();
         return true;
@@ -674,6 +998,14 @@ var ACPProtocolHandler = class {
   async sendNotification(params) {
     await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
   }
+  /** Best-effort durable persistence of a session + its recorded history. */
+  async persist(state) {
+    if (!this.store) return;
+    try {
+      await this.store.save(state, this.replayFor?.(state.id));
+    } catch {
+    }
+  }
   async sendError(id, code, message, data) {
     const error = { code, message };
     if (data !== void 0) error.data = data;
@@ -701,26 +1033,41 @@ function errorToJsonRpc(err) {
 var WrongStackACPServer = class {
   transport;
   handler;
+  options;
+  /** HTTP server when transport mode is HTTP. */
+  httpServer = null;
   running = false;
   constructor(opts = {}) {
+    this.options = opts;
     this.transport = new StdioTransport();
     const runTurn = opts.runTurn ?? defaultEchoRunTurn;
     this.handler = new ACPProtocolHandler({
       transport: this.transport,
       defaultCwd: opts.defaultCwd ?? process.cwd(),
       runTurn,
-      agentName: opts.agentName
+      agentName: opts.agentName,
+      ...opts.replayFor ? { replayFor: opts.replayFor } : {},
+      ...opts.seedFor ? { seedFor: opts.seedFor } : {},
+      ...opts.store ? { store: opts.store } : {}
     });
   }
   /**
-   * Start the server. Blocks until the client disconnects.
-   *
-   * 1. Print the legacy `[wstack-acp]\n` marker so the client knows the
-   *    process is the ACP server (the old `StdioTransport` handshake).
-   * 2. Loop: read messages, dispatch to the handler, until EOF / error.
+   * Start the server. Mode depends on `options.transport`:
+   * - 'stdio' (default): reads JSON-RPC from stdin, writes to stdout.
+   * - number: listens as HTTP on the given port.
    */
   async start() {
-    this.transport.sendStartupMarker();
+    const transportMode = this.options.transport;
+    if (typeof transportMode === "number") {
+      await this.startHttp(transportMode);
+    } else {
+      await this.startStdio();
+    }
+  }
+  async startStdio() {
+    if (this.options.legacyStartupMarker) {
+      this.transport.sendStartupMarker();
+    }
     this.running = true;
     while (this.running) {
       const msg = await this.transport.read();
@@ -730,10 +1077,80 @@ var WrongStackACPServer = class {
     }
     this.transport.close();
   }
+  async startHttp(port) {
+    const host = this.options.host ?? "127.0.0.1";
+    const handler = this.handler;
+    this.httpServer = createServer(async (req, res) => {
+      const selfOrigin = `http://${host}:${port}`;
+      const reqOrigin = Array.isArray(req.headers.origin) ? req.headers.origin[0] : req.headers.origin;
+      if (reqOrigin && reqOrigin !== selfOrigin) {
+        res.writeHead(403);
+        res.end(JSON.stringify({ error: "cross-origin request forbidden" }));
+        return;
+      }
+      if (reqOrigin) res.setHeader("Access-Control-Allow-Origin", reqOrigin);
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(405);
+        res.end(JSON.stringify({ error: "method not allowed" }));
+        return;
+      }
+      let body = "";
+      for await (const chunk of req) {
+        body += chunk;
+      }
+      let msg;
+      try {
+        msg = JSON.parse(body);
+      } catch {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: { code: -32700, message: "Parse error" } }));
+        return;
+      }
+      const notifications = [];
+      let response = null;
+      const originalSend = this.transport.send.bind(this.transport);
+      this.transport.send = async (m) => {
+        if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+          response = m;
+        } else if (m.method === "session/update") {
+          notifications.push(m.params);
+        } else {
+          notifications.push(m);
+        }
+      };
+      try {
+        await handler.handleMessage(msg);
+      } finally {
+        this.transport.send = originalSend;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const responseBody = response !== null ? { ...response, notifications } : { notifications };
+      res.end(JSON.stringify(responseBody));
+    });
+    return new Promise((resolve3) => {
+      this.httpServer.listen(port, host, () => {
+        writeErr(`[wstack-acp] HTTP server listening on http://${host}:${port}
+`);
+        this.running = true;
+        resolve3();
+      });
+    });
+  }
   /** Stop the server. */
   stop() {
     this.running = false;
     this.transport.close();
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
+    }
   }
 };
 var defaultEchoRunTurn = async (_input, _emit) => {
@@ -751,6 +1168,115 @@ if (isEntrypoint) {
     process.exit(1);
   });
 }
+
+// src/client/websocket-transport.ts
+var WebSocketClientTransport = class {
+  ws = null;
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  start() {
+    const WS = globalThis.WebSocket;
+    if (!WS) {
+      return Promise.reject(
+        new Error(
+          "global WebSocket is not available \u2014 Node \u2265 22 is required for the remote ACP transport"
+        )
+      );
+    }
+    const timeoutMs = this.opts.handshakeTimeoutMs ?? 3e4;
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      const ws = new WS(this.opts.url, this.opts.protocols);
+      this.ws = ws;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(new Error(`WebSocket failed to open within ${timeoutMs}ms`));
+      }, timeoutMs);
+      ws.addEventListener("open", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve3();
+      });
+      ws.addEventListener("error", (ev) => {
+        if (settled) {
+          this.closed = true;
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "WebSocket error";
+        reject(new Error(message));
+      });
+      ws.addEventListener("close", () => {
+        this.closed = true;
+      });
+      ws.addEventListener("message", (ev) => {
+        this.onData(ev.data);
+      });
+    });
+  }
+  send(msg) {
+    if (this.closed || !this.ws) {
+      return Promise.reject(new Error("WebSocket transport is not open"));
+    }
+    try {
+      this.ws.send(JSON.stringify(msg));
+      return Promise.resolve();
+    } catch (err) {
+      return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  stop() {
+    this.closed = true;
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  onData(data) {
+    const text = typeof data === "string" ? data : data instanceof ArrayBuffer ? Buffer.from(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
+    if (!text.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      for (const line of text.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          this.dispatch(JSON.parse(line));
+        } catch {
+        }
+      }
+      return;
+    }
+    this.dispatch(msg);
+  }
+  dispatch(msg) {
+    for (const handler of [...this.handlers]) {
+      try {
+        handler(msg);
+      } catch {
+      }
+    }
+  }
+};
 var DEFAULT_OPTIONS = {
   asyncTools: true,
   pollIntervalMs: 500,
@@ -793,6 +1319,7 @@ var ToolTranslator = class {
    */
   async callTool(transport, name, args, callId = crypto.randomUUID()) {
     await transport.send({
+      jsonrpc: "2.0",
       method: "tools/call",
       id: callId,
       params: { name, arguments: args }
@@ -815,11 +1342,11 @@ var ToolTranslator = class {
 var FsError = class extends Error {
   code;
   path;
-  constructor(code, path3, message) {
+  constructor(code, path4, message) {
     super(message);
     this.name = "FsError";
     this.code = code;
-    this.path = path3;
+    this.path = path4;
   }
 };
 var FileServer = class {
@@ -913,12 +1440,11 @@ function randomHex(bytes) {
 }
 
 // src/client/permission.ts
-var defaultPermissionPolicy = async (req) => {
-  if (req.signal.aborted) return { outcome: "cancelled" };
-  const ranked = [...req.options].sort((a, b) => {
+function pickAllow(options) {
+  const ranked = [...options].sort((a, b) => {
     const score = (k) => {
-      if (k === "allow_always") return 0;
-      if (k === "allow_once") return 1;
+      if (k === "allow_once") return 0;
+      if (k === "allow_always") return 1;
       if (k === "reject_once") return 2;
       return 3;
     };
@@ -929,7 +1455,33 @@ var defaultPermissionPolicy = async (req) => {
     return { outcome: "cancelled" };
   }
   return { outcome: "selected", optionId: chosen.optionId };
+}
+function pickReject(options) {
+  const reject = options.find(
+    (o) => o.kind === "reject_once" || o.kind === "reject_always"
+  );
+  return reject ? { outcome: "selected", optionId: reject.optionId } : { outcome: "cancelled" };
+}
+var READ_ONLY_KINDS = /* @__PURE__ */ new Set(["read", "search", "fetch", "think"]);
+var defaultPermissionPolicy = async (req) => {
+  if (req.signal.aborted) return { outcome: "cancelled" };
+  return pickAllow(req.options);
+};
+var readOnlyPermissionPolicy = async (req) => {
+  if (req.signal.aborted) return { outcome: "cancelled" };
+  const kind = req.toolCall.kind;
+  if (kind && READ_ONLY_KINDS.has(kind)) {
+    return pickAllow(req.options);
+  }
+  return pickReject(req.options);
 };
+function makePermissionPolicy(decide) {
+  return async (req) => {
+    if (req.signal.aborted) return { outcome: "cancelled" };
+    const allow = await decide(req);
+    return allow ? pickAllow(req.options) : pickReject(req.options);
+  };
+}
 var TerminalServer = class {
   terminals = /* @__PURE__ */ new Map();
   projectRoot;
@@ -1125,6 +1677,12 @@ var ACPSession = class _ACPSession {
   nextId = 1;
   /** True after close() has been called. */
   closed = false;
+  // Agent-provided info from the initialize handshake
+  agentCapabilities = {};
+  agentInfo = null;
+  authMethods = [];
+  /** Protocol version negotiated with the agent during initialize. */
+  negotiatedVersion = ACP_PROTOCOL_VERSION;
   constructor(opts, transport) {
     this.opts = opts;
     this.transport = transport;
@@ -1146,6 +1704,36 @@ var ACPSession = class _ACPSession {
     this.terminalServer = new TerminalServer(termOpts);
     this.permissionPolicy = opts.permissionPolicy ?? defaultPermissionPolicy;
   }
+  // ──────────────────────────────────────────────────────────────────────
+  // Public accessors
+  // ──────────────────────────────────────────────────────────────────────
+  /** Agent capabilities advertised during initialize. */
+  getCapabilities() {
+    return { ...this.agentCapabilities };
+  }
+  /** Authentication methods advertised by the agent. */
+  getAuthMethods() {
+    return [...this.authMethods];
+  }
+  /** Agent info (name, title, version) from initialize. */
+  getAgentInfo() {
+    return this.agentInfo;
+  }
+  /** Whether the agent requires authentication (has auth methods). */
+  requiresAuth() {
+    return this.authMethods.length > 0;
+  }
+  /** Current session id, if one exists. */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /** Protocol version negotiated during initialize. */
+  getNegotiatedVersion() {
+    return this.negotiatedVersion;
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Lifecycle — start
+  // ──────────────────────────────────────────────────────────────────────
   /**
    * Spawn the child, run the initialize handshake, install the
    * message dispatch, and return a ready session.
@@ -1155,20 +1743,37 @@ var ACPSession = class _ACPSession {
       command: opts.command,
       args: opts.args ? [...opts.args] : [],
       handshakeTimeoutMs: 3e4,
-      // ACPSession is the v1 CLIENT side: it speaks to external agents
-      // (Claude Code, Gemini CLI, …) that do NOT emit a `[wstack-acp]\n`
-      // startup marker. The transport should treat the child as ready
-      // as soon as the process is spawned and stdout is flowing.
       skipHandshakeMarker: true
     };
     if (opts.env !== void 0) transportOpts.env = opts.env;
     if (opts.cwd !== void 0) transportOpts.cwd = opts.cwd;
     const transport = new ClientTransport(transportOpts);
+    return _ACPSession.attach(opts, transport, `failed to spawn ${opts.command}`);
+  }
+  /**
+   * Connect to a REMOTE ACP agent over a WebSocket instead of spawning a
+   * local subprocess. `opts.command` is ignored for the wire (a label is
+   * still useful for `role`); everything else (projectRoot sandbox for
+   * fs/terminal, timeouts, permission policy, MCP servers) applies the same.
+   */
+  static async connectWebSocket(wsOpts, opts) {
+    const transport = new WebSocketClientTransport(wsOpts);
+    return _ACPSession.attach(opts, transport, `failed to connect to ${wsOpts.url}`);
+  }
+  /**
+   * Connect using a caller-supplied transport. Lets advanced callers plug
+   * in their own wire (SDK streams, in-process pipes, test doubles).
+   */
+  static async connect(transport, opts) {
+    return _ACPSession.attach(opts, transport, "failed to connect transport");
+  }
+  /** Shared connect path: start the transport, install dispatch, handshake. */
+  static async attach(opts, transport, spawnErrLabel) {
     try {
       await transport.start();
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new ACPSessionError("spawn_failed", `failed to spawn ${opts.command}: ${msg}`, err);
+      throw new ACPSessionError("spawn_failed", `${spawnErrLabel}: ${msg}`, err);
     }
     const session = new _ACPSession(opts, transport);
     transport.onMessage((msg) => session.handleMessage(msg));
@@ -1183,14 +1788,16 @@ var ACPSession = class _ACPSession {
     }
     return session;
   }
+  // ──────────────────────────────────────────────────────────────────────
+  // Initialization
+  // ──────────────────────────────────────────────────────────────────────
   async initialize() {
     const id = this.allocId();
     const result = await this.sendRequest(id, "initialize", {
       protocolVersion: ACP_PROTOCOL_VERSION,
       clientCapabilities: {
         fs: { readTextFile: true, writeTextFile: true },
-        terminal: true,
-        promptCapabilities: { image: false, audio: false, embeddedContext: true }
+        terminal: true
       },
       clientInfo: { name: "wrongstack", title: "WrongStack", version: "0.263.0" }
     });
@@ -1201,53 +1808,344 @@ var ACPSession = class _ACPSession {
       throw new ACPSessionError("protocol_error", "initialize returned no protocolVersion");
     }
     const r = result;
-    if (r.protocolVersion !== ACP_PROTOCOL_VERSION) {
+    if (r.protocolVersion > ACP_PROTOCOL_VERSION) {
       throw new ACPSessionError(
         "unsupported_capability",
-        `agent speaks protocolVersion=${r.protocolVersion}, client speaks ${ACP_PROTOCOL_VERSION}`
+        `agent requires protocolVersion=${r.protocolVersion}, client supports up to ${ACP_PROTOCOL_VERSION}`
       );
     }
+    this.negotiatedVersion = r.protocolVersion;
+    this.agentCapabilities = r.agentCapabilities ?? {};
+    this.agentInfo = r.agentInfo ?? null;
+    this.authMethods = r.authMethods ?? [];
     this.state = "ready";
   }
+  // ──────────────────────────────────────────────────────────────────────
+  // Authentication
+  // ──────────────────────────────────────────────────────────────────────
   /**
-   * Run one prompt turn. Creates a session if needed, sends the
-   * prompt, streams session/update notifications, and resolves with
-   * the agent's response.
+   * Authenticate with the agent using one of the advertised auth methods.
+   * Call this AFTER start() and BEFORE any session/new call.
    *
-   * Cancellation: if `signal` aborts mid-prompt, we send
-   * `session/cancel` (a notification per spec) and keep accepting
+   * Throws ACPSessionError('auth_failed') if the agent rejects the
+   * authentication or if the methodId is not in the advertised list.
+   */
+  async authenticate(methodId) {
+    if (this.state === "closed") {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (this.state !== "ready") {
+      throw new ACPSessionError(
+        "protocol_error",
+        `authenticate called in state=${this.state} (expected 'ready')`
+      );
+    }
+    if (!this.authMethods.some((m) => m.id === methodId)) {
+      throw new ACPSessionError(
+        "auth_failed",
+        `auth method "${methodId}" not in advertised methods: ${this.authMethods.map((m) => m.id).join(", ")}`
+      );
+    }
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "authenticate", { methodId });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
+    }
+    this.state = "authenticated";
+  }
+  /**
+   * Log out from the current authenticated session.
+   * Only callable if the agent advertises `auth.logout` capability.
+   */
+  async logout() {
+    if (this.state === "closed") {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (!this.agentCapabilities.auth?.logout) {
+      throw new ACPSessionError(
+        "unsupported_capability",
+        "agent does not support logout (auth.logout capability not advertised)"
+      );
+    }
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "logout", {});
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
+    }
+    this.state = "ready";
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Session management
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Load an existing session. The agent replays the conversation history
+   * via session/update notifications before responding.
+   *
+   * Only works if the agent advertises `loadSession` capability.
+   *
+   * @param sessionId - The session to load
+   * @param mcpServers - Optional MCP servers (defaults to options.mcpServers)
+   * @param cwd - Optional working directory (defaults to options.cwd or projectRoot)
+   */
+  async loadSession(sessionId, mcpServers, cwd) {
+    if (this.closed) {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (!this.agentCapabilities.loadSession) {
+      throw new ACPSessionError(
+        "unsupported_capability",
+        "agent does not support session/load (loadSession capability not advertised)"
+      );
+    }
+    if (this.sessionId) {
+      await this.closeSession();
+    }
+    this.resetScratch();
+    const servers = this.filterMcpServers(mcpServers ?? this.opts.mcpServers);
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/load", {
+      sessionId,
+      cwd: cwd ?? this.opts.cwd ?? this.opts.projectRoot,
+      mcpServers: servers
+    });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
+    }
+    this.sessionId = sessionId;
+  }
+  /**
+   * Resume an existing session without replaying history.
+   *
+   * Only works if the agent advertises `sessionCapabilities.resume`.
+   *
+   * @param sessionId - The session to resume
+   * @param mcpServers - Optional MCP servers (defaults to options.mcpServers)
+   * @param cwd - Optional working directory (defaults to options.cwd or projectRoot)
+   */
+  async resumeSession(sessionId, mcpServers, cwd) {
+    if (this.closed) {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (!this.agentCapabilities.sessionCapabilities?.resume) {
+      throw new ACPSessionError(
+        "unsupported_capability",
+        "agent does not support session/resume (sessionCapabilities.resume not advertised)"
+      );
+    }
+    if (this.sessionId) {
+      await this.closeSession();
+    }
+    const servers = this.filterMcpServers(mcpServers ?? this.opts.mcpServers);
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/resume", {
+      sessionId,
+      cwd: cwd ?? this.opts.cwd ?? this.opts.projectRoot,
+      mcpServers: servers
+    });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/resume failed: ${result.message}`, result);
+    }
+    this.sessionId = sessionId;
+  }
+  /**
+   * List existing sessions known to the agent.
+   *
+   * Only works if the agent advertises `sessionCapabilities.list`.
+   */
+  async listSessions(cursor, cwd) {
+    if (this.closed) {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (!this.agentCapabilities.sessionCapabilities?.list) {
+      throw new ACPSessionError(
+        "unsupported_capability",
+        "agent does not support session/list (sessionCapabilities.list not advertised)"
+      );
+    }
+    const id = this.allocId();
+    const params = {};
+    if (cursor !== void 0) params.cursor = cursor;
+    if (cwd !== void 0) params.cwd = cwd;
+    const result = await this.sendRequest(id, "session/list", params);
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
+    }
+    const r = result;
+    return {
+      sessions: r.sessions ?? [],
+      nextCursor: r.nextCursor
+    };
+  }
+  /**
+   * Delete a session from the agent's session list.
+   *
+   * Only works if the agent advertises `sessionCapabilities.delete`.
+   */
+  async deleteSession(sessionId) {
+    if (this.closed) {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (!this.agentCapabilities.sessionCapabilities?.delete) {
+      throw new ACPSessionError(
+        "unsupported_capability",
+        "agent does not support session/delete (sessionCapabilities.delete not advertised)"
+      );
+    }
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/delete", { sessionId });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/delete failed: ${result.message}`, result);
+    }
+    if (this.sessionId === sessionId) {
+      this.sessionId = null;
+    }
+  }
+  /**
+   * Fork a session — create a new session from an existing one.
+   */
+  async forkSession(sourceSessionId, cwd, mcpServers) {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const servers = this.filterMcpServers(mcpServers ?? this.opts.mcpServers);
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/fork", {
+      sessionId: sourceSessionId,
+      cwd: cwd ?? this.opts.cwd ?? this.opts.projectRoot,
+      ...servers.length > 0 ? { mcpServers: servers } : {}
+    });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
+    }
+    const newId = result.sessionId;
+    if (typeof newId !== "string" || !newId) {
+      throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
+    }
+    return newId;
+  }
+  /**
+   * Set the active mode for a session.
+   */
+  async setMode(sessionId, modeId) {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/set_mode", { sessionId, modeId });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/set_mode failed: ${result.message}`, result);
+    }
+  }
+  /**
+   * Set a configuration option for a session.
+   */
+  async setConfigOption(sessionId, configId, value) {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/set_config_option", {
+      sessionId,
+      configId,
+      value
+    });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `session/set_config_option failed: ${result.message}`, result);
+    }
+  }
+  /**
+   * List available providers and the current provider.
+   */
+  async listProviders() {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "providers/list", {});
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `providers/list failed: ${result.message}`, result);
+    }
+    const r = result;
+    return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+  }
+  /**
+   * Send an MCP message to the agent for routing.
+   */
+  async mcpMessage(connectionId, message) {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "mcp/message", { connectionId, message });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
+    }
+    return result;
+  }
+  /**
+   * Set the active provider for the agent.
+   */
+  async setProvider(providerId, config) {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
+    }
+  }
+  /**
+   * Disable the current provider.
+   */
+  async disableProvider() {
+    if (this.closed) throw new ACPSessionError("closed", "session is closed");
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "providers/disable", {});
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("prompt_failed", `providers/disable failed: ${result.message}`, result);
+    }
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Prompt
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Run one prompt turn. Creates a session if needed, sends the
+   * prompt, streams session/update notifications, and resolves with
+   * the agent's response.
+   *
+   * @param blocks - Content blocks to send. Use `textContent()` for plain
+   *   text, or include ImageContent/AudioContent if the agent's
+   *   `promptCapabilities` allow it.
+   * @param signal - AbortSignal for cancellation.
+   *
+   * Cancellation: if `signal` aborts mid-prompt, we send
+   * `session/cancel` (a notification per spec) and keep accepting
    * updates until the agent returns with `stopReason: 'cancelled'`.
    * The result is the same shape as a normal turn, with
    * `stopReason === 'cancelled'`.
    */
-  async prompt(text, signal) {
+  async prompt(blocks, signal, onProgress) {
     if (this.closed) {
       throw new ACPSessionError("closed", "session is closed");
     }
-    if (this.state !== "ready" && this.state !== "done") {
+    if (this.state !== "ready" && this.state !== "authenticated" && this.state !== "done") {
       throw new ACPSessionError("protocol_error", `prompt called in state=${this.state}`);
     }
     if (signal.aborted) {
-      return { text: "", stopReason: "cancelled", hasText: false };
+      return emptyRunResult("cancelled");
     }
     if (!this.sessionId) {
       await this.createSession();
     }
     this.resetScratch();
+    this.progressHandler = onProgress ?? null;
     const promptId = this.allocId();
     const turnPromise = this.sendRequest(
       promptId,
       "session/prompt",
       {
         sessionId: this.sessionId,
-        prompt: [textContent(text)]
+        prompt: blocks
       },
       this.timeoutMs
     );
     let cancelled = false;
     const onAbort = () => {
       cancelled = true;
-      this.transport.send({ method: "session/cancel", params: { sessionId: this.sessionId } }).catch(() => {
+      this.transport.send({
+        jsonrpc: "2.0",
+        method: "session/cancel",
+        params: { sessionId: this.sessionId }
+      }).catch(() => {
       });
     };
     signal.addEventListener("abort", onAbort, { once: true });
@@ -1265,6 +2163,7 @@ var ACPSession = class _ACPSession {
       throw new ACPSessionError("prompt_failed", `session/prompt failed: ${msg}`, err);
     } finally {
       signal.removeEventListener("abort", onAbort);
+      this.progressHandler = null;
     }
     this.state = "done";
     if (isJsonRpcError(response)) {
@@ -1277,14 +2176,18 @@ var ACPSession = class _ACPSession {
       stopReason,
       hasText: finalText.length > 0,
       usage: this.scratch.usage,
-      plan: this.scratch.plan
+      plan: this.scratch.plan,
+      toolCalls: [...this.scratch.toolCalls.values()],
+      diffs: this.scratch.diffs,
+      thoughts: this.scratch.thoughts
     };
   }
   async createSession() {
+    const servers = this.filterMcpServers(this.opts.mcpServers);
     const id = this.allocId();
     const result = await this.sendRequest(id, "session/new", {
       cwd: this.opts.cwd ?? this.opts.projectRoot,
-      mcpServers: []
+      mcpServers: servers
     });
     if (isJsonRpcError(result)) {
       throw new ACPSessionError(
@@ -1303,12 +2206,40 @@ var ACPSession = class _ACPSession {
     }
     this.sessionId = sessionId;
   }
+  /**
+   * Close the current session gracefully (if the agent supports it).
+   *
+   * Sends `session/close` JSON-RPC request, then clears the local
+   * session id. Best-effort — errors are swallowed so the caller can
+   * always proceed to transport teardown.
+   */
+  async closeSession() {
+    if (!this.sessionId) return;
+    const sid = this.sessionId;
+    this.sessionId = null;
+    if (this.agentCapabilities.sessionCapabilities?.close) {
+      const id = this.allocId();
+      try {
+        await this.sendRequest(id, "session/close", { sessionId: sid }, 1e4);
+      } catch {
+      }
+    }
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Lifecycle — close
+  // ──────────────────────────────────────────────────────────────────────
   /** Tear down the session and kill the child process. */
   async close() {
     if (this.closed) return;
     this.closed = true;
     this.state = "closed";
     this.terminalServer.releaseAll();
+    if (this.sessionId && this.agentCapabilities.sessionCapabilities?.close) {
+      try {
+        await this.closeSession();
+      } catch {
+      }
+    }
     for (const [, p] of this.pending) {
       clearTimeout(p.timeoutHandle);
       p.reject(new ACPSessionError("closed", "session was closed"));
@@ -1319,6 +2250,24 @@ var ACPSession = class _ACPSession {
     } catch {
     }
   }
+  // ──────────────────────────────────────────────────────────────────────
+  // Helpers
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Filter MCP servers according to agent capabilities.
+   * - Stdio servers are always included.
+   * - HTTP servers are only included if agent supports mcpCapabilities.http.
+   * - SSE servers are only included if agent supports mcpCapabilities.sse.
+   */
+  filterMcpServers(servers) {
+    if (!servers || servers.length === 0) return [];
+    const mcpCaps = this.agentCapabilities.mcpCapabilities ?? {};
+    return servers.filter((s) => {
+      if ("type" in s && s.type === "http") return mcpCaps.http === true;
+      if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
+      return true;
+    });
+  }
   // ────────────────────────────────────────────────────────────────────
   // Wire layer
   // ────────────────────────────────────────────────────────────────────
@@ -1352,6 +2301,28 @@ var ACPSession = class _ACPSession {
       });
     });
   }
+  /**
+   * Send a JSON-RPC 2.0 success response to an agent-initiated request.
+   *
+   * Per JSON-RPC 2.0 (and the official ACP SDK's message router) a Response
+   * object MUST carry `jsonrpc: "2.0"` and MUST NOT carry a `method` field —
+   * the SDK classifies any object with a `method` key as a Request and drops
+   * it as a response, so an agent's `fs/*`, `terminal/*`, or
+   * `session/request_permission` callback would hang forever. The legacy
+   * `ACPMessage` type predates v1 (requires `method`, lacks `jsonrpc`), so we
+   * build the correct wire object and cast at the boundary.
+   */
+  sendResult(id, result) {
+    return this.transport.send({ jsonrpc: "2.0", id, result });
+  }
+  /** Send a JSON-RPC 2.0 error response (no `method` field, per spec). */
+  sendErrorResponse(id, code, message) {
+    return this.transport.send({
+      jsonrpc: "2.0",
+      id,
+      error: { code, message }
+    });
+  }
   handleMessage(msg) {
     if (msg.id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
       const pending = this.pending.get(msg.id);
@@ -1381,6 +2352,23 @@ var ACPSession = class _ACPSession {
       void this.handleTerminalRequest(msg);
       return;
     }
+    if (msg.method === "mcp/connect" || msg.method === "mcp/message" || msg.method === "mcp/disconnect") {
+      if (msg.id !== void 0) {
+        this.sendResult(msg.id, {}).catch(() => {
+        });
+      }
+      return;
+    }
+    if (msg.method === "elicitation/create" || msg.method === "elicitation/complete") {
+      if (msg.id !== void 0) {
+        this.sendResult(msg.id, {}).catch(() => {
+        });
+      }
+      return;
+    }
+    if (msg.method === "$/cancel_request") {
+      return;
+    }
     if (msg.method) {
       console.warn(`[acp-session] unhandled method: ${msg.method}`);
     }
@@ -1389,31 +2377,44 @@ var ACPSession = class _ACPSession {
     const update = msg.params?.update;
     if (typeof update !== "object" || update === null) return;
     const u = update;
+    this.emitProgress({ type: "raw", update: u });
     switch (u.sessionUpdate) {
       case "agent_message_chunk": {
         const text = extractText(u.content);
-        if (text) this.accumulatedText(text);
+        if (text) {
+          this.scratch.text += text;
+          this.emitProgress({ type: "message", text });
+        }
         return;
       }
-      case "thought_chunk":
+      case "thought_chunk": {
+        const text = extractText(u.content);
+        if (text) {
+          this.scratch.thoughts += text;
+          this.emitProgress({ type: "thought", text });
+        }
         return;
+      }
       case "tool_call":
-      case "tool_call_update":
+      case "tool_call_update": {
+        this.captureToolCall(u, u.sessionUpdate === "tool_call");
         return;
+      }
       case "plan":
         if (Array.isArray(u.entries)) {
-          this.accumulatedPlan(u.entries);
+          this.scratch.plan = u.entries;
+          this.emitProgress({ type: "plan", entries: u.entries });
         }
         return;
       case "usage_update":
         if (typeof u.used === "number" && typeof u.size === "number") {
-          this.accumulatedUsage({
+          const usage = {
             used: u.used,
             size: u.size,
-            ...typeof u.cost === "object" && u.cost !== null ? {
-              cost: u.cost
-            } : {}
-          });
+            ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
+          };
+          this.scratch.usage = usage;
+          this.emitProgress({ type: "usage", usage });
         }
         return;
       case "available_commands_update":
@@ -1421,27 +2422,62 @@ var ACPSession = class _ACPSession {
       case "config_option_update":
       case "session_info_update":
       case "user_message_chunk":
+      case "next_edit_suggestions":
+      case "elicitation":
         return;
       default:
-        console.warn(`[acp-session] unhandled sessionUpdate: ${u.sessionUpdate}`);
         return;
     }
   }
-  // Per-prompt scratch state. Reset at the start of each prompt() and
-  // read at the end to assemble the ACPSessionRunResult. The stream
-  // pump writes to it via the three `accumulated*` helpers below.
-  scratch = { text: "" };
-  accumulatedText(chunk) {
-    this.scratch.text += chunk;
-  }
-  accumulatedPlan(entries) {
-    this.scratch.plan = entries;
+  /**
+   * Fold a `tool_call` / `tool_call_update` notification into the scratch
+   * tool-call map (deduped by toolCallId), extract any `diff` content into
+   * the diffs list, and emit live progress.
+   */
+  captureToolCall(u, isNew) {
+    const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : "";
+    if (!toolCallId) return;
+    const prev = this.scratch.toolCalls.get(toolCallId);
+    const record = {
+      toolCallId,
+      title: typeof u.title === "string" ? u.title : prev?.title ?? toolCallId,
+      kind: typeof u.kind === "string" ? u.kind : prev?.kind,
+      status: typeof u.status === "string" ? u.status : prev?.status ?? (isNew ? "pending" : "in_progress"),
+      rawInput: isRecord(u.rawInput) ? u.rawInput : prev?.rawInput,
+      rawOutput: isRecord(u.rawOutput) ? u.rawOutput : prev?.rawOutput
+    };
+    this.scratch.toolCalls.set(toolCallId, record);
+    if (Array.isArray(u.content)) {
+      for (const c of u.content) {
+        if (c && typeof c === "object" && c.type === "diff") {
+          const diff = {
+            path: c.path,
+            oldText: c.oldText,
+            newText: c.newText
+          };
+          this.scratch.diffs.push(diff);
+          this.emitProgress({ type: "diff", diff });
+        }
+      }
+    }
+    this.emitProgress({
+      type: isNew ? "tool_call" : "tool_call_update",
+      toolCall: record
+    });
   }
-  accumulatedUsage(u) {
-    this.scratch.usage = u;
+  emitProgress(event) {
+    if (!this.progressHandler) return;
+    try {
+      this.progressHandler(event);
+    } catch {
+    }
   }
+  /** Live progress handler installed for the duration of a `prompt()` turn. */
+  progressHandler = null;
+  // Per-prompt scratch state
+  scratch = { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
   resetScratch() {
-    this.scratch = { text: "" };
+    this.scratch = { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
   }
   async handlePermissionRequest(msg) {
     const id = msg.id;
@@ -1450,11 +2486,7 @@ var ACPSession = class _ACPSession {
     const toolCall = params?.toolCall;
     const options = Array.isArray(params?.options) ? params.options : [];
     if (!toolCall) {
-      await this.transport.send({
-        id,
-        method: "session/request_permission",
-        error: { code: -32602, message: "toolCall is required" }
-      });
+      await this.sendErrorResponse(id, -32602, "toolCall is required");
       return;
     }
     const policyAbort = new AbortController();
@@ -1463,22 +2495,14 @@ var ACPSession = class _ACPSession {
       options,
       signal: policyAbort.signal
     });
-    await this.transport.send({
-      id,
-      method: "session/request_permission",
-      result: { outcome }
-    });
+    await this.sendResult(id, { outcome });
   }
   async handleFsRequest(msg) {
     const id = msg.id;
     if (id === void 0) return;
     const params = msg.params;
     if (!params?.path) {
-      await this.transport.send({
-        id,
-        method: msg.method,
-        error: { code: -32602, message: "path is required" }
-      });
+      await this.sendErrorResponse(id, -32602, "path is required");
       return;
     }
     try {
@@ -1487,19 +2511,19 @@ var ACPSession = class _ACPSession {
           sessionId: params.sessionId ?? "",
           path: params.path
         });
-        await this.transport.send({ id, method: msg.method, result });
+        await this.sendResult(id, result);
       } else {
         await this.fileServer.writeTextFile({
           sessionId: params.sessionId ?? "",
           path: params.path,
           content: params.content ?? ""
         });
-        await this.transport.send({ id, method: msg.method, result: {} });
+        await this.sendResult(id, {});
       }
     } catch (err) {
       const code = err instanceof FsError ? -32602 : -32603;
       const message = err instanceof Error ? err.message : String(err);
-      await this.transport.send({ id, method: msg.method, error: { code, message } });
+      await this.sendErrorResponse(id, code, message);
     }
   }
   async handleTerminalRequest(msg) {
@@ -1524,192 +2548,73 @@ var ACPSession = class _ACPSession {
             createOpts.outputByteLimit = params.outputByteLimit;
           }
           const result = this.terminalServer.create(createOpts);
-          await this.transport.send({ id, method: msg.method, result });
+          await this.sendResult(id, result);
           return;
         }
         case "terminal/output": {
           const terminalId = String(params.terminalId ?? "");
           const out = this.terminalServer.output(terminalId);
-          await this.transport.send({ id, method: msg.method, result: out });
+          await this.sendResult(id, out);
           return;
         }
         case "terminal/wait_for_exit": {
           const terminalId = String(params.terminalId ?? "");
           const exit = await this.terminalServer.waitForExit(terminalId);
-          await this.transport.send({ id, method: msg.method, result: exit });
+          await this.sendResult(id, exit);
           return;
         }
         case "terminal/kill": {
           const terminalId = String(params.terminalId ?? "");
           this.terminalServer.kill(terminalId);
-          await this.transport.send({ id, method: msg.method, result: {} });
+          await this.sendResult(id, {});
           return;
         }
         case "terminal/release": {
           const terminalId = String(params.terminalId ?? "");
           this.terminalServer.release(terminalId);
-          await this.transport.send({ id, method: msg.method, result: {} });
+          await this.sendResult(id, {});
           return;
         }
         default:
-          await this.transport.send({
-            id,
-            method: msg.method,
-            error: { code: -32601, message: `unknown method: ${msg.method}` }
-          });
+          await this.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      await this.transport.send({
-        id,
-        method: msg.method,
-        error: { code: -32603, message }
-      });
+      await this.sendErrorResponse(id, -32603, message);
     }
   }
 };
 function textContent(text) {
   return { type: "text", text };
 }
+function imageContent(mimeType, data) {
+  return { type: "image", mimeType, data };
+}
+function audioContent(mimeType, data) {
+  return { type: "audio", mimeType, data };
+}
 function extractText(block) {
   if (typeof block !== "object" || block === null) return "";
   const b = block;
   if (b.type === "text" && typeof b.text === "string") return b.text;
-  return "";
-}
-
-// src/integration/acp-subagent-runner.ts
-var ACP_AGENT_COMMANDS = {
-  cline: {
-    command: "npx",
-    args: ["-y", "@agentify/cline"],
-    role: "cline"
-  },
-  "gemini-cli": {
-    command: "gemini",
-    role: "gemini-cli"
-  },
-  copilot: {
-    command: "gh",
-    args: ["copilot", "agent"],
-    role: "copilot"
-  },
-  openhands: {
-    command: "openhands",
-    role: "openhands"
-  },
-  goose: {
-    command: "goose",
-    role: "goose"
+  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
+    return b.resource.text;
   }
-};
-async function makeACPSubagentRunner(options) {
-  const { runner, stop } = await makeACPSubagentRunnerWithStop(options);
-  const wrappedRunner = async (task, ctx) => {
-    try {
-      return await runner(task, ctx);
-    } finally {
-      stop();
-    }
-  };
-  return wrappedRunner;
+  return "";
 }
-async function makeACPSubagentRunnerWithStop(options) {
-  const projectRoot = options.projectRoot ?? options.cwd ?? process.cwd();
-  const timeoutMs = options.timeoutMs ?? 5 * 6e4;
-  const runner = async (task, ctx) => {
-    let session = null;
-    try {
-      session = await ACPSession.start({
-        command: options.command,
-        ...options.args !== void 0 ? { args: options.args } : {},
-        ...options.env !== void 0 ? { env: options.env } : {},
-        ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
-        projectRoot,
-        timeoutMs,
-        role: options.role
-      });
-    } catch (err) {
-      throw acpErrorToSubagentError(err, options.role ?? "acp-subagent");
-    }
-    try {
-      const result = await session.prompt(task.description, ctx.signal);
-      return {
-        result: result.text,
-        iterations: 1,
-        toolCalls: 0
-      };
-    } catch (err) {
-      if (err instanceof ACPSessionError && err.kind === "aborted") {
-        throw acpErrorToSubagentError(err, options.role ?? "acp-subagent");
-      }
-      throw acpErrorToSubagentError(err, options.role ?? "acp-subagent");
-    } finally {
-      try {
-        await session.close();
-      } catch {
-      }
-    }
-  };
-  const stop = () => {
-  };
-  return { runner, stop };
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function acpErrorToSubagentError(err, subagentId) {
-  if (err instanceof ACPSessionError) {
-    const kind = mapACPKind(err.kind);
-    return {
-      kind,
-      message: `${subagentId}: ${err.message}`,
-      retryable: isRetryable(kind),
-      cause: {
-        name: err.name,
-        message: err.message,
-        ...err.stack !== void 0 ? { stack: err.stack } : {}
-      }
-    };
-  }
-  const message = err instanceof Error ? err.message : String(err);
+function emptyRunResult(stopReason) {
   return {
-    kind: "bridge_failed",
-    message: `${subagentId}: ${message}`,
-    retryable: false,
-    cause: {
-      name: err instanceof Error ? err.name : "Error",
-      message,
-      ...err instanceof Error && err.stack !== void 0 ? { stack: err.stack } : {}
-    }
+    text: "",
+    stopReason,
+    hasText: false,
+    toolCalls: [],
+    diffs: [],
+    thoughts: ""
   };
 }
-function mapACPKind(acpKind) {
-  switch (acpKind) {
-    case "spawn_failed":
-    case "init_failed":
-    case "session_create_failed":
-    case "agent_died":
-    case "protocol_error":
-      return "bridge_failed";
-    case "prompt_failed":
-      return "tool_failed";
-    case "aborted":
-      return "aborted_by_parent";
-    case "closed":
-    case "unsupported_capability":
-      return "unknown";
-  }
-}
-function isRetryable(kind) {
-  switch (kind) {
-    case "provider_5xx":
-    case "provider_rate_limit":
-    case "provider_timeout":
-    case "tool_threw":
-    case "budget_timeout":
-      return true;
-    default:
-      return false;
-  }
-}
 
 // src/registry/agents.catalog.ts
 var AGENTS_CATALOG = [
@@ -1719,9 +2624,12 @@ var AGENTS_CATALOG = [
     displayName: "Claude Code",
     vendor: "anthropic",
     probe: { command: "claude", args: ["--version"] },
-    // Native ACP entry is gated behind the SDK adapter in early releases;
-    // see https://agentclientprotocol.com/get-started/agents
-    acp: { command: "claude", args: [] },
+    // Claude Code does not speak stdio ACP from the bare `claude` binary —
+    // it drops into its interactive TUI. The official ACP adapter
+    // (`@agentclientprotocol/claude-agent-acp`, registry id `claude-acp`)
+    // wraps the logged-in Claude Code CLI and translates ACP ↔ Claude Code.
+    // Verify with `/acp probe claude-code`; override via `config.acp.agents`.
+    acp: { command: "npx", args: ["-y", "@agentclientprotocol/claude-agent-acp"] },
     supports: {
       loadSession: true,
       promptImages: true,
@@ -1737,7 +2645,10 @@ var AGENTS_CATALOG = [
     displayName: "Gemini CLI",
     vendor: "google",
     probe: { command: "gemini", args: ["--version"] },
-    acp: { command: "gemini", args: [] },
+    // Gemini CLI (the @google/gemini-cli package, registry id `gemini`)
+    // speaks ACP behind `--acp`. We invoke the locally-installed binary so it
+    // uses the user's existing login. Confirm with `/acp probe gemini-cli`.
+    acp: { command: "gemini", args: ["--acp"] },
     supports: {
       loadSession: true,
       promptImages: true,
@@ -1753,7 +2664,10 @@ var AGENTS_CATALOG = [
     displayName: "Codex CLI",
     vendor: "openai",
     probe: { command: "codex", args: ["--version"] },
-    acp: { command: "codex", args: [] },
+    // Bare `codex` has no stdio-ACP entry; the official adapter
+    // (`@agentclientprotocol/codex-acp`, registry id `codex-acp`) wraps the
+    // logged-in Codex CLI. Confirm with `/acp probe codex-cli`.
+    acp: { command: "npx", args: ["-y", "@agentclientprotocol/codex-acp"] },
     supports: {
       loadSession: false,
       promptImages: false,
@@ -1769,7 +2683,9 @@ var AGENTS_CATALOG = [
     displayName: "GitHub Copilot CLI",
     vendor: "github",
     probe: { command: "gh", args: ["copilot", "--help"] },
-    acp: { command: "gh", args: ["copilot"] },
+    // ACP is in the standalone @github/copilot CLI (registry id
+    // `github-copilot-cli`), not the `gh copilot` extension. Use the package.
+    acp: { command: "npx", args: ["-y", "@github/copilot", "--acp"] },
     supports: {
       loadSession: false,
       promptImages: false,
@@ -1785,9 +2701,10 @@ var AGENTS_CATALOG = [
     displayName: "Cline",
     vendor: "community",
     probe: { command: "npx", args: ["--version"] },
+    // Registry id `cline`: the `cline` npm package speaks ACP behind `--acp`.
     acp: {
       command: "npx",
-      args: ["-y", "@agentify/cline"]
+      args: ["-y", "cline", "--acp"]
     },
     supports: {
       loadSession: true,
@@ -1803,7 +2720,7 @@ var AGENTS_CATALOG = [
     displayName: "Goose",
     vendor: "community",
     probe: { command: "goose", args: ["--version"] },
-    acp: { command: "goose", args: [] },
+    acp: { command: "goose", args: ["acp"] },
     supports: {
       loadSession: true,
       promptImages: true,
@@ -1835,7 +2752,8 @@ var AGENTS_CATALOG = [
     displayName: "Qwen Code",
     vendor: "community",
     probe: { command: "qwen", args: ["--version"] },
-    acp: { command: "qwen", args: [] },
+    // Qwen Code (the @qwen-code/qwen-code package) speaks ACP behind `--acp`.
+    acp: { command: "qwen", args: ["--acp"] },
     supports: {
       loadSession: false,
       promptImages: false,
@@ -1865,7 +2783,8 @@ var AGENTS_CATALOG = [
     displayName: "OpenCode",
     vendor: "community",
     probe: { command: "opencode", args: ["--version"] },
-    acp: { command: "opencode", args: [] },
+    // OpenCode speaks ACP via its `acp` subcommand (registry id `opencode`).
+    acp: { command: "opencode", args: ["acp"] },
     supports: {
       loadSession: true,
       promptImages: true,
@@ -1895,7 +2814,8 @@ var AGENTS_CATALOG = [
     displayName: "Cursor",
     vendor: "community",
     probe: { command: "cursor", args: ["--version"] },
-    acp: { command: "cursor", args: [] },
+    // Cursor's ACP entry is the `cursor-agent acp` binary (registry id `cursor`).
+    acp: { command: "cursor-agent", args: ["acp"] },
     supports: {
       loadSession: true,
       promptImages: true,
@@ -1909,8 +2829,369 @@ var AGENTS_CATALOG = [
 function findAgentDescriptor(id) {
   return AGENTS_CATALOG.find((a) => a.id === id);
 }
+
+// src/integration/acp-subagent-runner.ts
+var ACP_AGENT_COMMANDS = {
+  cline: {
+    command: "npx",
+    args: ["-y", "@agentify/cline"],
+    role: "cline"
+  },
+  "gemini-cli": {
+    command: "gemini",
+    role: "gemini-cli"
+  },
+  copilot: {
+    command: "gh",
+    args: ["copilot", "agent"],
+    role: "copilot"
+  },
+  openhands: {
+    command: "openhands",
+    role: "openhands"
+  },
+  goose: {
+    command: "goose",
+    role: "goose"
+  }
+};
+async function makeACPSubagentRunner(options) {
+  const { runner, stop } = await makeACPSubagentRunnerWithStop(options);
+  const wrappedRunner = async (task, ctx) => {
+    try {
+      return await runner(task, ctx);
+    } finally {
+      stop();
+    }
+  };
+  return wrappedRunner;
+}
+async function makeACPSubagentRunnerWithStop(options) {
+  const projectRoot = options.projectRoot ?? options.cwd ?? process.cwd();
+  const timeoutMs = options.timeoutMs ?? 5 * 6e4;
+  const persistent = options.persistent === true;
+  let shared = null;
+  const startSession = async () => {
+    return ACPSession.start({
+      command: options.command,
+      ...options.args !== void 0 ? { args: options.args } : {},
+      ...options.env !== void 0 ? { env: options.env } : {},
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+      projectRoot,
+      timeoutMs,
+      role: options.role,
+      ...options.permissionPolicy !== void 0 ? { permissionPolicy: options.permissionPolicy } : {},
+      ...options.mcpServers !== void 0 ? { mcpServers: options.mcpServers } : {}
+    });
+  };
+  const runner = async (task, ctx) => {
+    let session;
+    const reuse = persistent && shared !== null;
+    try {
+      session = reuse ? shared : await startSession();
+      if (persistent) shared = session;
+    } catch (err) {
+      throw acpErrorToSubagentError(err, options.role ?? "acp-subagent");
+    }
+    const onProgress = (event) => {
+      try {
+        ctx.budget.markActivity();
+      } catch {
+      }
+      options.onProgress?.(event);
+    };
+    try {
+      const result = await session.prompt(
+        [textContent(task.description)],
+        ctx.signal,
+        onProgress
+      );
+      return {
+        result: result.text,
+        iterations: 1,
+        toolCalls: result.toolCalls.length
+      };
+    } catch (err) {
+      throw acpErrorToSubagentError(err, options.role ?? "acp-subagent");
+    } finally {
+      if (!persistent) {
+        try {
+          await session.close();
+        } catch {
+        }
+      }
+    }
+  };
+  const stop = async () => {
+    if (shared) {
+      const s = shared;
+      shared = null;
+      try {
+        await s.close();
+      } catch {
+      }
+    }
+  };
+  return { runner, stop };
+}
+function acpErrorToSubagentError(err, subagentId) {
+  if (err instanceof ACPSessionError) {
+    const kind = mapACPKind(err.kind);
+    return {
+      kind,
+      message: `${subagentId}: ${err.message}`,
+      retryable: isRetryable(kind),
+      cause: {
+        name: err.name,
+        message: err.message,
+        ...err.stack !== void 0 ? { stack: err.stack } : {}
+      }
+    };
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    kind: "bridge_failed",
+    message: `${subagentId}: ${message}`,
+    retryable: false,
+    cause: {
+      name: err instanceof Error ? err.name : "Error",
+      message,
+      ...err instanceof Error && err.stack !== void 0 ? { stack: err.stack } : {}
+    }
+  };
+}
+function mapACPKind(acpKind) {
+  switch (acpKind) {
+    case "spawn_failed":
+    case "init_failed":
+    case "session_create_failed":
+    case "agent_died":
+    case "protocol_error":
+      return "bridge_failed";
+    case "prompt_failed":
+      return "tool_failed";
+    case "auth_failed":
+    case "logout_failed":
+      return "bridge_failed";
+    case "aborted":
+      return "aborted_by_parent";
+    case "closed":
+    case "unsupported_capability":
+      return "unknown";
+  }
+}
+function isRetryable(kind) {
+  switch (kind) {
+    case "provider_5xx":
+    case "provider_rate_limit":
+    case "provider_timeout":
+    case "tool_threw":
+    case "budget_timeout":
+      return true;
+    default:
+      return false;
+  }
+}
+var REGISTRY_ID_ALIASES = {
+  "claude-code": "claude-acp",
+  "gemini-cli": "gemini",
+  "codex-cli": "codex-acp",
+  copilot: "github-copilot-cli"
+};
+function resolveAcpAgentCommand(id, overrides, live) {
+  const ov = overrides?.[id];
+  if (ov && typeof ov.command === "string" && ov.command.length > 0) {
+    const out = {
+      command: ov.command,
+      args: [...ov.args ?? []],
+      role: id
+    };
+    if (ov.env) out.env = ov.env;
+    return out;
+  }
+  const desc = findAgentDescriptor(id);
+  if (desc) {
+    const out = {
+      command: desc.acp.command,
+      args: [...desc.acp.args ?? []],
+      role: id
+    };
+    if (desc.acp.env) out.env = desc.acp.env;
+    return out;
+  }
+  const liveEntry = live?.[id] ?? live?.[REGISTRY_ID_ALIASES[id] ?? ""];
+  if (liveEntry && typeof liveEntry.command === "string" && liveEntry.command.length > 0) {
+    const out = {
+      command: liveEntry.command,
+      args: [...liveEntry.args ?? []],
+      role: id
+    };
+    if (liveEntry.env) out.env = liveEntry.env;
+    return out;
+  }
+  const fromMap = ACP_AGENT_COMMANDS[id];
+  if (fromMap) return fromMap;
+  return null;
+}
+async function runOneAcpTask(opts) {
+  const role = opts.role ?? "acp";
+  const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+  const { runner, stop } = await makeACPSubagentRunnerWithStop({
+    command: opts.command,
+    ...opts.args !== void 0 ? { args: opts.args } : {},
+    ...opts.env !== void 0 ? { env: opts.env } : {},
+    ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+    ...opts.projectRoot !== void 0 ? { projectRoot: opts.projectRoot } : {},
+    role,
+    timeoutMs,
+    ...opts.onProgress !== void 0 ? { onProgress: opts.onProgress } : {},
+    ...opts.permissionPolicy !== void 0 ? { permissionPolicy: opts.permissionPolicy } : {}
+  });
+  try {
+    const budget = new SubagentBudget({
+      timeoutMs,
+      maxIterations: 2e3,
+      maxToolCalls: 5e3
+    });
+    budget.start();
+    const ctx = {
+      subagentId: role,
+      config: { id: role, name: role, role, provider: "acp", prompt: "" },
+      budget,
+      signal: opts.signal ?? new AbortController().signal,
+      bridge: null
+    };
+    const result = await runner({ id: `acp-${role}`, description: opts.task }, ctx);
+    return {
+      result: result.result == null ? "" : String(result.result),
+      iterations: result.iterations,
+      toolCalls: result.toolCalls
+    };
+  } finally {
+    try {
+      await stop();
+    } catch {
+    }
+  }
+}
+async function probeAcpAgent(idOrCmd, opts) {
+  const id = typeof idOrCmd === "string" ? idOrCmd : idOrCmd.role ?? idOrCmd.command;
+  const cmd = typeof idOrCmd === "string" ? resolveAcpAgentCommand(idOrCmd, opts?.overrides, opts?.live) : idOrCmd;
+  if (!cmd) return { id, ok: false, ms: 0, error: "unknown agent" };
+  const timeoutMs = opts?.timeoutMs ?? 8e3;
+  const startedAt = Date.now();
+  let session = null;
+  try {
+    session = await ACPSession.start({
+      command: cmd.command,
+      ...cmd.args !== void 0 ? { args: cmd.args } : {},
+      ...cmd.env !== void 0 ? { env: cmd.env } : {},
+      projectRoot: opts?.projectRoot ?? process.cwd(),
+      // Bounds the `initialize` request: a CLI that spawns but never answers
+      // the handshake fails after this instead of blocking.
+      timeoutMs
+    });
+    const info = session.getAgentInfo();
+    return {
+      id,
+      ok: true,
+      ms: Date.now() - startedAt,
+      ...info ? { agentInfo: info } : {}
+    };
+  } catch (err) {
+    return {
+      id,
+      ok: false,
+      ms: Date.now() - startedAt,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    if (session) {
+      try {
+        await session.close();
+      } catch {
+      }
+    }
+  }
+}
+async function probeAcpAgents(opts) {
+  const localTimeout = opts.timeoutMs ?? 2e4;
+  const pkgTimeout = opts.packageTimeoutMs ?? 9e4;
+  const ids = opts.agentIds;
+  const byId = /* @__PURE__ */ new Map();
+  const local = [];
+  const pkg = [];
+  const cmds = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const cmd = opts.resolveCmd(id);
+    cmds.set(id, cmd);
+    if (!cmd) continue;
+    if (cmd.command === "npx" || cmd.command === "uvx") pkg.push(id);
+    else local.push(id);
+  }
+  const runPhase = async (phaseIds, concurrency, timeoutMs) => {
+    let next = 0;
+    const workerCount = Math.min(Math.max(1, concurrency), Math.max(1, phaseIds.length));
+    const workers = [];
+    for (let w = 0; w < workerCount; w++) {
+      workers.push(
+        (async () => {
+          while (true) {
+            const current = next++;
+            if (current >= phaseIds.length) return;
+            const id = phaseIds[current];
+            if (opts.signal?.aborted) {
+              byId.set(id, { id, ok: false, ms: 0, error: "aborted" });
+              continue;
+            }
+            const cmd = cmds.get(id);
+            const r = await probeAcpAgent(cmd, {
+              timeoutMs,
+              ...opts.projectRoot !== void 0 ? { projectRoot: opts.projectRoot } : {}
+            });
+            r.id = id;
+            byId.set(id, r);
+            opts.onProgress?.(id, r);
+          }
+        })()
+      );
+    }
+    await Promise.all(workers);
+  };
+  for (const id of ids) {
+    if (cmds.get(id) === null) {
+      const r = { id, ok: false, ms: 0, error: "unknown agent" };
+      byId.set(id, r);
+      opts.onProgress?.(id, r);
+    }
+  }
+  await runPhase(local, opts.concurrency ?? 4, localTimeout);
+  await runPhase(pkg, 2, pkgTimeout);
+  return ids.map((id) => byId.get(id) ?? { id, ok: false, ms: 0, error: "not probed" });
+}
 var PROBE_TIMEOUT_MS = 5e3;
 var PROBE_CACHE_MS = 5e3;
+var MAX_PARALLEL_PROBES = 4;
+async function probeWithBound(items, worker, limit) {
+  const safeLimit = Math.max(1, Math.min(limit, items.length));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(safeLimit, items.length);
+  const runners = [];
+  for (let i = 0; i < workerCount; i++) {
+    runners.push(
+      (async () => {
+        while (true) {
+          const current = nextIndex++;
+          if (current >= items.length) return;
+          results[current] = await worker(items[current]);
+        }
+      })()
+    );
+  }
+  await Promise.all(runners);
+  return results;
+}
 async function defaultProbe(desc, timeoutMs) {
   const start = Date.now();
   return new Promise((resolve3) => {
@@ -2010,13 +3291,21 @@ var EnsembleRegistry = class {
   /**
    * Probe every catalog entry in parallel and return the detection
    * results. Results are cached for `PROBE_CACHE_MS`.
+   *
+   * Probes are dispatched with bounded concurrency (`MAX_PARALLEL_PROBES`)
+   * so cold-start lists do not spawn `catalog.length` subprocesses at
+   * once — which is especially wasteful on Windows shells and on hosts
+   * with large agent catalogs. The output order still matches
+   * `this.catalog` so callers can index by position.
    */
   async list() {
     if (this.cache && Date.now() - this.cache.at < PROBE_CACHE_MS) {
       return this.cache.result;
     }
-    const result = await Promise.all(
-      this.catalog.map((d) => this.detect(d))
+    const result = await probeWithBound(
+      this.catalog,
+      (d) => this.detect(d),
+      MAX_PARALLEL_PROBES
     );
     this.cache = { at: Date.now(), result };
     return result;
@@ -2045,31 +3334,126 @@ var EnsembleRegistry = class {
     return all.filter((a) => a.installed);
   }
 };
-var defaultEnsembleCmdResolver = (id) => {
-  const fromMap = ACP_AGENT_COMMANDS[id];
-  if (fromMap) return fromMap;
-  const desc = findAgentDescriptor(id);
-  if (!desc) return null;
-  const out = {
-    command: desc.acp.command,
-    args: [...desc.acp.args ?? []],
-    role: id
+
+// src/registry/acp-registry-fetch.ts
+var ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+function currentPlatformKey() {
+  const os = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "darwin" : "linux";
+  const arch = process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : process.arch;
+  return `${os}-${arch}`;
+}
+function basename(cmd) {
+  const cleaned = cmd.replace(/^\.\//, "").replace(/\\/g, "/");
+  const parts = cleaned.split("/");
+  return parts[parts.length - 1] || cleaned;
+}
+function mapRegistryEntry(entry, platformKey = currentPlatformKey()) {
+  if (!entry || typeof entry.id !== "string" || entry.id.length === 0) return null;
+  const dist = entry.distribution;
+  let acp = null;
+  if (dist?.npx?.package) {
+    acp = { command: "npx", args: ["-y", dist.npx.package, ...dist.npx.args ?? []] };
+  } else if (dist?.uvx?.package) {
+    acp = { command: "uvx", args: [dist.uvx.package, ...dist.uvx.args ?? []] };
+  } else if (dist?.binary) {
+    const target = dist.binary[platformKey];
+    if (target?.cmd) {
+      acp = {
+        command: basename(target.cmd),
+        args: [...target.args ?? []],
+        ...target.env ? { env: target.env } : {}
+      };
+    }
+  }
+  if (!acp) return null;
+  const probeCmd = acp.command === "npx" ? "npx" : acp.command === "uvx" ? "uvx" : acp.command;
+  return {
+    id: entry.id,
+    displayName: entry.name ?? entry.id,
+    vendor: inferVendor(entry),
+    probe: { command: probeCmd, args: ["--version"] },
+    acp,
+    supports: { loadSession: true, promptImages: true, terminal: true, fs: true },
+    integration: "native",
+    docs: entry.repository ?? entry.website ?? ""
   };
-  if (desc.acp.env) out.env = desc.acp.env;
-  return out;
-};
+}
+function inferVendor(entry) {
+  const hay = `${entry.id} ${entry.name ?? ""} ${(entry.authors ?? []).join(" ")}`.toLowerCase();
+  if (hay.includes("anthropic") || hay.includes("claude")) return "anthropic";
+  if (hay.includes("google") || hay.includes("gemini")) return "google";
+  if (hay.includes("openai") || hay.includes("codex")) return "openai";
+  if (hay.includes("github") || hay.includes("copilot")) return "github";
+  return "community";
+}
+async function fetchAcpRegistry(opts = {}) {
+  const url = opts.url ?? ACP_REGISTRY_URL;
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onParentAbort = () => controller.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) controller.abort();
+    else opts.signal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    if (!res.ok) {
+      throw new Error(`ACP registry fetch failed: HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    const rawAgents = Array.isArray(body) ? body : Array.isArray(body?.agents) ? body.agents : null;
+    if (!rawAgents) {
+      throw new Error("ACP registry response had no agents array");
+    }
+    const platformKey = opts.platformKey ?? currentPlatformKey();
+    const agents = [];
+    for (const raw of rawAgents) {
+      const mapped = mapRegistryEntry(raw, platformKey);
+      if (mapped) agents.push(mapped);
+    }
+    return { fetchedAt: opts.now ?? (/* @__PURE__ */ new Date()).toISOString(), agents };
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", onParentAbort);
+  }
+}
+var DEFAULT_MAX_CONCURRENCY = 4;
+async function mapBound(items, worker, limit) {
+  const results = new Array(items.length);
+  if (items.length === 0) return results;
+  const safeLimit = Math.max(1, Math.min(limit, items.length));
+  let nextIndex = 0;
+  const workerCount = Math.min(safeLimit, items.length);
+  const runners = [];
+  for (let w = 0; w < workerCount; w++) {
+    runners.push(
+      (async () => {
+        while (true) {
+          const current = nextIndex++;
+          if (current >= items.length) return;
+          results[current] = await worker(items[current], current);
+        }
+      })()
+    );
+  }
+  await Promise.all(runners);
+  return results;
+}
+var defaultEnsembleCmdResolver = (id) => resolveAcpAgentCommand(id);
 function setResult(results, agentId, patch) {
   const i = results.findIndex((r) => r.agentId === agentId);
   if (i < 0) return;
   const current = results[i];
   results[i] = { ...current, ...patch };
 }
-async function runOne(agentId, cmd, task, timeoutMs, signal) {
+async function runOne(agentId, cmd, task, timeoutMs, signal, onProgress) {
   const startedAt = Date.now();
   try {
     const { runner, stop } = await makeACPSubagentRunnerWithStop({
       ...cmd,
-      timeoutMs
+      timeoutMs,
+      ...onProgress ? { onProgress: (event) => onProgress(agentId, event) } : {}
     });
     try {
       const budget = new SubagentBudget({
@@ -2173,8 +3557,13 @@ async function runEnsemble(opts) {
     }
     runnable.push({ id, cmd });
   }
-  await Promise.allSettled(
-    runnable.map(async ({ id, cmd }) => {
+  const concurrency = Math.max(
+    1,
+    opts.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY
+  );
+  await mapBound(
+    runnable,
+    async ({ id, cmd }) => {
       if (opts.signal?.aborted) {
         setResult(results, id, {
           status: "cancelled",
@@ -2183,9 +3572,10 @@ async function runEnsemble(opts) {
         });
         return;
       }
-      const outcome = await runOne(id, cmd, opts.task, timeoutMs, opts.signal);
+      const outcome = await runOne(id, cmd, opts.task, timeoutMs, opts.signal, opts.onProgress);
       setResult(results, id, outcome);
-    })
+    },
+    concurrency
   );
   const summary = { succeeded: 0, failed: 0, skipped: 0, cancelled: 0 };
   for (const r of results) {
@@ -2242,7 +3632,212 @@ Ensemble summary: ${succeeded} succeeded, ${failed} failed, ${cancelled} cancell
   );
   return lines.join("\n");
 }
+function firstLine(s) {
+  const line = s.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+  return line.length > 120 ? `${line.slice(0, 117)}\u2026` : line;
+}
+function randomMarker() {
+  return `ACP_OK_${Math.random().toString(36).slice(2, 8).toUpperCase()}`;
+}
+async function benchOne(agentId, cmd, opts) {
+  const checks = [];
+  const startedAt = opts.now();
+  let session = null;
+  const signal = opts.signal ?? new AbortController().signal;
+  const hsStart = opts.now();
+  try {
+    session = await ACPSession.start({
+      command: cmd.command,
+      ...cmd.args !== void 0 ? { args: [...cmd.args] } : {},
+      ...cmd.env !== void 0 ? { env: cmd.env } : {},
+      projectRoot: opts.projectRoot,
+      timeoutMs: opts.timeoutMs
+    });
+  } catch (err) {
+    const reason2 = err instanceof Error ? err.message : String(err);
+    checks.push({ name: "handshake", ok: false, detail: reason2 });
+    return {
+      agentId,
+      status: "fail",
+      checks,
+      reason: reason2,
+      handshakeMs: opts.now() - hsStart,
+      durationMs: opts.now() - startedAt
+    };
+  }
+  const handshakeMs = opts.now() - hsStart;
+  const agentInfo = session.getAgentInfo() ?? void 0;
+  checks.push({
+    name: "handshake",
+    ok: true,
+    detail: agentInfo ? `${agentInfo.name} ${agentInfo.version}` : void 0
+  });
+  let promptMs;
+  let sample;
+  let reason;
+  try {
+    const pStart = opts.now();
+    const res = await session.prompt(
+      [textContent(`Reply with exactly this token and nothing else: ${opts.marker}`)],
+      signal
+    );
+    promptMs = opts.now() - pStart;
+    sample = res.text ? firstLine(res.text) : void 0;
+    const promptOk = res.hasText && res.stopReason !== "refusal";
+    checks.push({
+      name: "prompt",
+      ok: promptOk,
+      detail: `stopReason=${res.stopReason}${res.hasText ? "" : ", no text"}`
+    });
+    const markerOk = res.text.includes(opts.marker);
+    checks.push({
+      name: "marker",
+      ok: markerOk,
+      detail: markerOk ? void 0 : "reply did not contain the token"
+    });
+    if (opts.checkFs) {
+      const fileToken = `FILE_${opts.marker}`;
+      const fileName = `acp-bench-${opts.marker}.txt`;
+      const filePath = path.join(opts.projectRoot, fileName);
+      let fsOk = false;
+      let fsDetail;
+      try {
+        await fsp.writeFile(filePath, fileToken, "utf8");
+        const fsRes = await session.prompt(
+          [
+            textContent(
+              `Read the file "${fileName}" in the current directory and reply with its exact contents.`
+            )
+          ],
+          signal
+        );
+        fsOk = fsRes.text.includes(fileToken);
+        if (!fsOk) fsDetail = "agent did not return the file contents (may not have used a read tool)";
+      } catch (err) {
+        fsDetail = err instanceof Error ? err.message : String(err);
+      } finally {
+        await fsp.rm(filePath, { force: true }).catch(() => {
+        });
+      }
+      checks.push({ name: "fs", ok: fsOk, detail: fsDetail });
+    }
+  } catch (err) {
+    reason = err instanceof Error ? err.message : String(err);
+    checks.push({ name: "prompt", ok: false, detail: reason });
+  } finally {
+    try {
+      await session.close();
+    } catch {
+    }
+  }
+  const required = checks.filter((c) => c.name !== "fs" || opts.checkFs);
+  const allReq = required.every((c) => c.ok);
+  const handshakeOk = checks.find((c) => c.name === "handshake")?.ok === true;
+  const status = allReq ? "pass" : handshakeOk ? "partial" : "fail";
+  return {
+    agentId,
+    status,
+    checks,
+    ...agentInfo ? { agentInfo } : {},
+    handshakeMs,
+    ...promptMs !== void 0 ? { promptMs } : {},
+    ...sample ? { sample } : {},
+    ...reason ? { reason } : {},
+    durationMs: opts.now() - startedAt
+  };
+}
+async function runAcpBench(opts) {
+  const now = opts.now ?? Date.now;
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const timeoutMs = opts.timeoutMs ?? 6e4;
+  const checkFs = opts.checkFs ?? false;
+  const marker = opts.marker ?? randomMarker();
+  const concurrency = Math.max(1, opts.concurrency ?? 2);
+  const seen = /* @__PURE__ */ new Set();
+  const ids = [];
+  for (const raw of opts.agentIds) {
+    const id = raw.trim();
+    if (id && !seen.has(id)) {
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+  const results = ids.map((agentId) => ({
+    agentId,
+    status: "skipped",
+    checks: [],
+    durationMs: 0,
+    reason: "unknown agent"
+  }));
+  const startMs = now();
+  const runnable = [];
+  ids.forEach((id, index) => {
+    const cmd = opts.resolveCmd(id);
+    if (cmd) runnable.push({ id, cmd, index });
+  });
+  let next = 0;
+  const workers = [];
+  const workerCount = Math.min(concurrency, runnable.length);
+  for (let w = 0; w < workerCount; w++) {
+    workers.push(
+      (async () => {
+        while (true) {
+          const current = next++;
+          if (current >= runnable.length) return;
+          const { id, cmd, index } = runnable[current];
+          if (opts.signal?.aborted) {
+            results[index] = {
+              agentId: id,
+              status: "skipped",
+              checks: [],
+              durationMs: 0,
+              reason: "aborted"
+            };
+            continue;
+          }
+          opts.onProgress?.(id, "start");
+          const r = await benchOne(id, cmd, {
+            projectRoot,
+            timeoutMs,
+            checkFs,
+            marker,
+            now,
+            ...opts.signal ? { signal: opts.signal } : {}
+          });
+          results[index] = r;
+          opts.onProgress?.(id, "done", r);
+        }
+      })()
+    );
+  }
+  await Promise.all(workers);
+  const summary = { pass: 0, partial: 0, fail: 0, skipped: 0 };
+  for (const r of results) summary[r.status]++;
+  return { results, summary, totalDurationMs: now() - startMs };
+}
+function renderAcpBenchText(result) {
+  const icon = (s) => s === "pass" ? "\u2713" : s === "partial" ? "\u25D0" : s === "skipped" ? "\u2013" : "\u2717";
+  const lines = ["ACP client bench:", ""];
+  if (result.results.length === 0) {
+    lines.push("No agents to bench.");
+    return lines.join("\n");
+  }
+  for (const r of result.results) {
+    const checks = r.checks.map((c) => `${c.ok ? "\u2713" : "\u2717"}${c.name}`).join(" ");
+    const timing = r.handshakeMs !== void 0 ? `  hs=${r.handshakeMs}ms${r.promptMs !== void 0 ? ` prompt=${r.promptMs}ms` : ""}` : "";
+    lines.push(`  ${icon(r.status)} ${r.agentId.padEnd(16)} ${r.status.toUpperCase().padEnd(7)} ${checks}${timing}`);
+    if (r.agentInfo) lines.push(`      agent: ${r.agentInfo.name} ${r.agentInfo.version}`);
+    if (r.sample) lines.push(`      reply: ${r.sample}`);
+    if (r.reason) lines.push(`      reason: ${r.reason}`);
+  }
+  const { pass, partial, fail, skipped } = result.summary;
+  lines.push("");
+  lines.push(
+    `Bench summary: ${pass} pass, ${partial} partial, ${fail} fail, ${skipped} skipped. (${result.totalDurationMs}ms total)`
+  );
+  return lines.join("\n");
+}
 
-export { ACPProtocolHandler, ACPSession, ACPSessionError, ACPToolsRegistry, ACP_AGENT_COMMANDS, AGENTS_CATALOG, ClientTransport, EnsembleRegistry, FileServer, FsError, StdioTransport, TerminalServer, ToolTranslator, WrongStackACPServer, defaultEnsembleCmdResolver, defaultPermissionPolicy, findAgentDescriptor, makeACPSubagentRunner, makeACPSubagentRunnerWithStop, renderEnsembleText, runEnsemble };
+export { ACPProtocolHandler, ACPSession, ACPSessionError, ACPToolsRegistry, ACP_AGENT_COMMANDS, ACP_REGISTRY_URL, AGENTS_CATALOG, ClientTransport, EnsembleRegistry, FileServer, FsError, REGISTRY_ID_ALIASES, StdioTransport, TerminalServer, ToolTranslator, WebSocketClientTransport, WrongStackACPServer, audioContent, currentPlatformKey, defaultEnsembleCmdResolver, defaultPermissionPolicy, fetchAcpRegistry, findAgentDescriptor, imageContent, makeACPSubagentRunner, makeACPSubagentRunnerWithStop, makePermissionPolicy, mapRegistryEntry, probeAcpAgent, probeAcpAgents, readOnlyPermissionPolicy, renderAcpBenchText, renderEnsembleText, resolveAcpAgentCommand, runAcpBench, runEnsemble, runOneAcpTask, textContent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map