@wrongstack/acp 0.260.0 → 0.265.1

package/dist/index.js

@@ -1,5 +1,9 @@
 import { writeErr, expectDefined } from '@wrongstack/core';
 import { fileURLToPath } from 'url';
+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 {
@@ -23,9 +27,9 @@ var StdioTransport = class {
   }
   send(msg) {
     if (this.closed) return Promise.resolve();
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       const line = JSON.stringify(msg) + "\n";
-      this.stdout.write(line, "utf8", () => resolve());
+      this.stdout.write(line, "utf8", () => resolve3());
     });
   }
   sendRaw(chunk) {
@@ -34,8 +38,8 @@ var StdioTransport = class {
   read() {
     if (this.messageQueue.length > 0) return Promise.resolve(expectDefined(this.messageQueue.shift()));
     if (this.closed) return Promise.resolve(null);
-    return new Promise((resolve) => {
-      this.resolveRead = resolve;
+    return new Promise((resolve3) => {
+      this.resolveRead = resolve3;
     });
   }
   onMessage(handler) {
@@ -64,9 +68,9 @@ var StdioTransport = class {
   }
   dispatch(msg) {
     if (this.resolveRead) {
-      const resolve = this.resolveRead;
+      const resolve3 = this.resolveRead;
       this.resolveRead = null;
-      resolve(msg);
+      resolve3(msg);
     } else {
       this.messageQueue.push(msg);
     }
@@ -106,22 +110,30 @@ var ClientTransport = class {
   }
   async start() {
     if (this.child) return;
-    const [{ spawn }, { buildChildEnv }] = await Promise.all([
+    const [{ spawn: spawn3 }, { buildChildEnv }] = await Promise.all([
       import('child_process'),
       import('@wrongstack/core')
     ]);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
         reject(
           new Error(`ACP child process failed to start within ${this.opts.handshakeTimeoutMs}ms`)
         );
       }, this.opts.handshakeTimeoutMs);
       try {
-        this.child = spawn(this.opts.command, this.opts.args ?? [], {
+        this.child = spawn3(this.opts.command, this.opts.args ?? [], {
           env: { ...buildChildEnv(), ...this.opts.env },
           cwd: this.opts.cwd,
           stdio: ["pipe", "pipe", "pipe"],
-          windowsHide: true
+          windowsHide: true,
+          // On Windows, most ACP-supporting tools (claude, gemini, codex,
+          // qwen, copilot) are installed as `.cmd` shims under
+          // AppData\Roaming\npm\. Node's spawn won't find them via
+          // `shell: false` because the .cmd extension is not in the
+          // default PATHEXT lookup. The argv here is always from our
+          // own static catalog or from a hardcoded spec, never from
+          // user input, so shell-expansion is bounded.
+          shell: process.platform === "win32"
         });
       } catch (err) {
         clearTimeout(timeout);
@@ -130,17 +142,24 @@ var ClientTransport = class {
       }
       const child = this.child;
       child.stdout.setEncoding("utf8");
+      const onReady = () => {
+        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");
         if (idx !== -1) {
           this.buffer = this.buffer.slice(idx + "[wstack-acp]\n".length);
           child.stdout.removeListener("data", waitForMarker);
-          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);
-          resolve();
+          onReady();
         }
       };
       child.stdout.on("data", waitForMarker);
@@ -156,19 +175,19 @@ var ClientTransport = class {
   }
   send(msg) {
     if (!this.child) return Promise.reject(new Error("ClientTransport not started"));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const line = JSON.stringify(msg) + "\n";
       this.child?.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve();
+        else resolve3();
       });
     });
   }
   read() {
     if (this.messageQueue.length > 0) return Promise.resolve(expectDefined(this.messageQueue.shift()));
     if (this.closed) return Promise.resolve(null);
-    return new Promise((resolve) => {
-      this.resolveRead = resolve;
+    return new Promise((resolve3) => {
+      this.resolveRead = resolve3;
     });
   }
   onMessage(handler) {
@@ -210,9 +229,9 @@ var ClientTransport = class {
   }
   dispatch(msg) {
     if (this.resolveRead) {
-      const resolve = this.resolveRead;
+      const resolve3 = this.resolveRead;
       this.resolveRead = null;
-      resolve(msg);
+      resolve3(msg);
     } else {
       this.messageQueue.push(msg);
     }
@@ -339,182 +358,366 @@ function toolToPriority(tool) {
   return "low";
 }
 
+// src/types/acp-v1.ts
+var ACP_PROTOCOL_VERSION = 1;
+
 // src/agent/protocol-handler.ts
-var WRONGSTACK_VERSION = "0.1.0";
-var WRONGSTACK_CAPABILITIES = [
-  "code-generation",
-  "async-tools",
-  "streaming",
-  "progress"
+function toWire(msg) {
+  return msg;
+}
+var WRONGSTACK_VERSION = "0.263.0";
+var DEFAULT_MODE_ID = "code";
+var DEFAULT_MODES = [
+  {
+    id: DEFAULT_MODE_ID,
+    name: "Code",
+    description: "Default agent mode for code-generation tasks."
+  }
 ];
 var ACPProtocolHandler = class {
-  constructor(transport, registry, context) {
-    this.transport = transport;
-    this.registry = registry;
-    this.context = context;
-  }
   transport;
-  registry;
-  context;
+  defaultCwd;
+  runTurn;
+  onSessionNew;
+  modes;
+  configOptions;
+  agentName;
   initialized = false;
-  signal = new AbortController();
-  pendingCalls = /* @__PURE__ */ new Map();
-  /** Wire an external abort signal from the ACP client */
-  wireAbortController(abortController) {
-    abortController.signal.addEventListener("abort", () => {
-      for (const id of this.pendingCalls.keys()) {
-        this.transport.send({ id, method: "cancel", result: { ok: true } }).catch((err) => console.debug(`[protocol-handler] cancel send failed: ${err}`));
-      }
+  sessions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  constructor(opts) {
+    this.transport = opts.transport;
+    this.defaultCwd = opts.defaultCwd;
+    this.runTurn = opts.runTurn;
+    this.onSessionNew = opts.onSessionNew ?? (() => {
     });
+    this.modes = opts.modes ?? DEFAULT_MODES;
+    this.configOptions = opts.configOptions ?? [];
+    this.agentName = opts.agentName ?? "wrongstack";
   }
-  /** Process one inbound message. Returns true if this was a terminal message. */
+  /**
+   * Process one inbound message. Returns true if this was a terminal
+   * message (rare; reserved for future use by the server's own
+   * shutdown signal).
+   */
   async handleMessage(msg) {
-    if (msg.id !== void 0) {
-      return this.handleRequest(msg);
+    if (typeof msg !== "object" || msg === null) return false;
+    const m = msg;
+    if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+      return false;
     }
-    return this.handleNotification(msg);
+    if (m.id !== void 0 && typeof m.method === "string") {
+      return this.handleRequest(m.id, m.method, m.params);
+    }
+    if (typeof m.method === "string") {
+      return this.handleNotification(m.method, m.params);
+    }
+    return false;
   }
-  async handleRequest(req) {
-    if (req.method !== "initialize" && !this.initialized) {
-      await this.sendError(req.id ?? null, -32e3, "Not initialized");
+  /** Abort all active turns and drop session state. */
+  close() {
+    for (const [, session] of this.sessions) {
+      session.abort.abort();
+    }
+    this.sessions.clear();
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // Requests
+  // ────────────────────────────────────────────────────────────────────
+  async handleRequest(id, method, params) {
+    if (method !== "initialize" && !this.initialized) {
+      await this.sendError(id, -32e3, "Not initialized");
       return false;
     }
-    const id = req.id;
-    switch (req.method) {
-      case "initialize":
-        return this.handleInitialize(req, id);
-      case "ping":
-        await this.transport.send({ id, method: "ping", result: { pong: true } });
-        return false;
-      case "tools/call":
-        return this.handleToolCall(req, id);
-      case "tools/list":
-        return this.handleToolsList(id);
-      case "cancel":
-        return this.handleCancel(id);
-      case "session/list":
-        return this.handleSessionList(id);
-      case "sessionInfoUpdate":
-        await this.transport.send({ id, method: "sessionInfoUpdate", result: { ok: true } });
-        return false;
-      default:
-        await this.sendError(id, -32601, `Unknown method: ${req.method}`);
-        return false;
+    try {
+      switch (method) {
+        case "initialize":
+          return await this.handleInitialize(id, params);
+        case "authenticate":
+          return await this.handleAuthenticate(id, params);
+        case "session/new":
+          return await this.handleSessionNew(id, params);
+        case "session/load":
+          return await this.handleSessionLoad(id, params);
+        case "session/prompt":
+          return await this.handleSessionPrompt(id, params);
+        case "session/set_mode":
+          return await this.handleSetMode(id, params);
+        case "session/set_config_option":
+          return await this.handleSetConfigOption(id, params);
+        case "session/list":
+          return await this.handleSessionList(id);
+        default:
+          await this.sendError(id, -32601, `Unknown method: ${method}`);
+          return false;
+      }
+    } catch (err) {
+      const { code, message, data } = errorToJsonRpc(err);
+      await this.sendError(id, code, message, data);
+      return false;
     }
   }
-  async handleNotification(n) {
-    if (n.method === "cancel") {
-      this.handleCancelNotification(n);
+  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;
     }
-    return false;
-  }
-  async handleInitialize(req, id) {
     this.initialized = true;
-    const result = {
-      capabilities: WRONGSTACK_CAPABILITIES,
-      agentName: "WrongStack",
-      agentVersion: WRONGSTACK_VERSION,
-      protocolVersion: req.params?.protocolVersion ?? "2024-11",
-      ...this.registry.buildToolList()
-    };
-    await this.transport.send({ id, method: "initialize", result });
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentCapabilities: {
+          loadSession: true,
+          promptCapabilities: {
+            image: false,
+            audio: false,
+            embeddedContext: true
+          }
+        },
+        agentInfo: {
+          name: this.agentName,
+          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: [],
+        modes: this.modes,
+        configOptions: this.configOptions
+      }
+    }));
     return false;
   }
-  async handleToolsList(id) {
-    await this.transport.send({
+  async handleAuthenticate(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
       id,
-      method: "tools/list",
-      result: this.registry.buildToolList()
+      result: { outcome: "unauthenticated" }
+    }));
+    return false;
+  }
+  async handleSessionNew(id, params) {
+    const p = params ?? {};
+    const cwd = typeof p.cwd === "string" ? p.cwd : this.defaultCwd;
+    const sessionId = `sess_${this.allocId()}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const state = {
+      id: sessionId,
+      cwd,
+      abort: new AbortController(),
+      modeId: DEFAULT_MODE_ID,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.sessions.set(sessionId, state);
+    this.onSessionNew(state);
+    await this.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        modeId: this.modes[0]?.id ?? DEFAULT_MODE_ID
+      }
     });
+    if (this.configOptions.length > 0) {
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "config_option_update",
+          configOptions: [...this.configOptions]
+        }
+      });
+    }
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        sessionId,
+        modes: this.modes,
+        configOptions: this.configOptions
+      }
+    }));
     return false;
   }
-  async handleToolCall(req, id) {
-    const { name, arguments: args } = req.params;
-    const runPromise = (async () => {
-      if (!this.registry.has(name)) {
-        return {
-          content: [{ type: "text", text: `Tool not found: ${name}` }],
-          isError: true
-        };
-      }
-      const result = await this.registry.execute(
-        name,
-        args,
-        this.context,
-        this.signal.signal
-      );
-      return result ?? { content: [{ type: "text", text: "Tool returned null" }], isError: false };
-    })();
-    this.pendingCalls.set(id, runPromise);
+  async handleSessionLoad(id, params) {
+    return this.handleSessionNew(id, params);
+  }
+  async handleSessionPrompt(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sessionId || !this.sessions.has(sessionId)) {
+      await this.sendError(id, -32e3, "unknown or missing sessionId");
+      return false;
+    }
+    if (!Array.isArray(p.prompt)) {
+      await this.sendError(id, -32602, "prompt must be an array of content blocks");
+      return false;
+    }
+    const session = this.sessions.get(sessionId);
+    if (session.abort.signal.aborted) {
+      session.abort = new AbortController();
+    }
+    const turnSignal = new AbortController();
+    const onCancel = () => turnSignal.abort();
+    session.abort.signal.addEventListener("abort", onCancel, { once: true });
+    let result;
     try {
-      const toolResult = await runPromise;
-      this.pendingCalls.delete(id);
-      const response = { method: "tools/call", id, result: toolResult };
-      await this.transport.send(response);
+      result = await this.runTurn(
+        { sessionId, prompt: p.prompt, signal: turnSignal.signal },
+        (update) => this.sendNotification({ sessionId, update })
+      );
     } catch (err) {
-      this.pendingCalls.delete(id);
-      const msg = err instanceof Error ? err.message : String(err);
-      await this.transport.send({
-        id,
-        method: "tools/call",
-        result: { content: [{ type: "text", text: msg }], isError: true }
-      });
+      session.abort.signal.removeEventListener("abort", onCancel);
+      const { code, message, data } = errorToJsonRpc(err);
+      await this.sendError(id, code, message, data);
+      return false;
     }
+    session.abort.signal.removeEventListener("abort", onCancel);
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: { stopReason: result.stopReason }
+    }));
     return false;
   }
-  async handleCancel(id) {
-    this.pendingCalls.delete(id);
-    await this.transport.send({ id, method: "cancel", result: { ok: true } });
+  async handleSetMode(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const modeId = typeof p.modeId === "string" ? p.modeId : null;
+    const session = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!session || !modeId || !this.modes.some((m) => m.id === modeId)) {
+      await this.sendError(id, -32602, "invalid sessionId or modeId");
+      return false;
+    }
+    session.modeId = modeId;
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.sendNotification({
+      sessionId,
+      update: { sessionUpdate: "current_mode_update", modeId }
+    });
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
     return false;
   }
-  handleCancelNotification(_n) {
+  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 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");
+      return false;
+    }
+    option.currentValue = value;
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions: [...this.configOptions]
+      }
+    });
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
+    return false;
   }
   async handleSessionList(id) {
-    await this.transport.send({
-      id,
-      method: "session/list",
-      result: { sessions: [] }
+    const sessions = Array.from(this.sessions.values()).map((s) => {
+      const out = {
+        sessionId: s.id,
+        cwd: s.cwd,
+        updatedAt: s.updatedAt
+      };
+      if (s.title !== void 0) out.title = s.title;
+      return out;
     });
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: { sessions }
+    }));
     return false;
   }
-  async sendError(id, code, message) {
-    if (id === null) return;
-    await this.transport.send({ id, method: "", error: { code, message } });
+  // ────────────────────────────────────────────────────────────────────
+  // Notifications
+  // ────────────────────────────────────────────────────────────────────
+  async handleNotification(method, params) {
+    switch (method) {
+      case "session/cancel": {
+        const p = params ?? {};
+        const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+        const session = sessionId ? this.sessions.get(sessionId) : void 0;
+        if (session) {
+          session.abort.abort();
+        }
+        return false;
+      }
+      case "exit":
+        this.close();
+        return true;
+      default:
+        return false;
+    }
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // Wire helpers
+  // ────────────────────────────────────────────────────────────────────
+  async sendNotification(params) {
+    await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
+  }
+  async sendError(id, code, message, data) {
+    const error = { code, message };
+    if (data !== void 0) error.data = data;
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, error }));
+  }
+  allocId() {
+    return this.nextId++;
   }
 };
+function errorToJsonRpc(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.code === "number" && typeof e.message === "string") {
+      const result = {
+        code: e.code,
+        message: e.message
+      };
+      if (e.data !== void 0) result.data = e.data;
+      return result;
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return { code: -32603, message };
+}
 var WrongStackACPServer = class {
   transport;
-  registry;
   handler;
   running = false;
-  constructor(opts) {
+  constructor(opts = {}) {
     this.transport = new StdioTransport();
-    this.registry = new ACPToolsRegistry(opts.owner);
-    this.registry.register(opts.tools);
-    this.handler = new ACPProtocolHandler(
-      this.transport,
-      this.registry,
-      // Future: WrongStack session/memory context for tool execution.
-      // When wired, this would carry session state, memory entries, and
-      // project metadata so ACP tools can self-contextualise.
-      // Tracked in docs/notes/refactor-2026-06-05.md §5.1.
-      {}
-    );
+    const runTurn = opts.runTurn ?? defaultEchoRunTurn;
+    this.handler = new ACPProtocolHandler({
+      transport: this.transport,
+      defaultCwd: opts.defaultCwd ?? process.cwd(),
+      runTurn,
+      agentName: opts.agentName
+    });
   }
   /**
    * Start the server. Blocks until the client disconnects.
    *
-   * 1. Send the startup marker `[wstack-acp]` so the client
-   *    knows which stdout line is the protocol boundary.
-   * 2. Loop: read messages, dispatch to handler, until EOF or error.
-   *
-   * Single dispatch path: every inbound message is read exactly once
-   * from the transport and passed to the protocol handler exactly once.
-   * An earlier version combined a `transport.onMessage` callback with
-   * this read loop, which caused every message to be processed twice
-   * (once by the callback, once by the loop) — duplicate tool calls
-   * and duplicate responses to the client. See the ACP double-dispatch
-   * fix in the security audit (P1-001).
+   * 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.
    */
   async start() {
     this.transport.sendStartupMarker();
@@ -533,8 +736,11 @@ var WrongStackACPServer = class {
     this.transport.close();
   }
 };
+var defaultEchoRunTurn = async (_input, _emit) => {
+  return { stopReason: "end_turn" };
+};
 async function main() {
-  const server = new WrongStackACPServer({ tools: [] });
+  const server = new WrongStackACPServer();
   await server.start();
 }
 var isEntrypoint = process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
@@ -550,32 +756,6 @@ var DEFAULT_OPTIONS = {
   pollIntervalMs: 500,
   totalTimeoutMs: 12e4
 };
-function extractTextFromContent(blocks) {
-  const parts = [];
-  for (const b of blocks) {
-    if (b.type === "text") parts.push(b.text);
-    else if (b.type === "resource") parts.push(`[resource: ${b.resource.uri}]`);
-    else if (b.type === "image") parts.push(`[image: ${b.data.slice(0, 20)}...]`);
-    else if (b.type === "progress") {
-      if (b.messages?.length) parts.push(b.messages.join("\n"));
-    }
-  }
-  return parts.join("\n");
-}
-function parseToolResponse(taskId, subagentId, response) {
-  const blocks = response.result.content;
-  const text = extractTextFromContent(blocks);
-  const isError = response.result.isError || text.toLowerCase().includes("error") || text.toLowerCase().includes("failed");
-  return {
-    taskId,
-    subagentId,
-    status: isError ? "failed" : "success",
-    result: text,
-    iterations: 1,
-    toolCalls: 1,
-    durationMs: 0
-  };
-}
 var ToolTranslator = class {
   opts;
   pending = /* @__PURE__ */ new Map();
@@ -617,12 +797,12 @@ var ToolTranslator = class {
       id: callId,
       params: { name, arguments: args }
     });
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(callId);
         reject(new Error(`Tool call ${name} timed out after ${this.opts.totalTimeoutMs}ms`));
       }, this.opts.totalTimeoutMs);
-      this.pending.set(callId, { resolve, reject, timeout });
+      this.pending.set(callId, { resolve: resolve3, reject, timeout });
     });
   }
   cancelAll() {
@@ -632,6 +812,771 @@ var ToolTranslator = class {
     this.pending.clear();
   }
 };
+var FsError = class extends Error {
+  code;
+  path;
+  constructor(code, path3, message) {
+    super(message);
+    this.name = "FsError";
+    this.code = code;
+    this.path = path3;
+  }
+};
+var FileServer = class {
+  root;
+  timeoutMs;
+  constructor(opts) {
+    this.root = path.resolve(opts.projectRoot);
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+  }
+  /** Read a text file. Returns the content as a string. */
+  async readTextFile(params) {
+    const safe = this.resolveInside(params.path);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const content = await fsp.readFile(safe, {
+        encoding: "utf8",
+        signal: controller.signal
+      });
+      return { content };
+    } catch (err) {
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `readTextFile timed out after ${this.timeoutMs}ms`);
+      }
+      throw mapFsError(err, safe);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Write a text file. Atomic via write-then-rename. */
+  async writeTextFile(params) {
+    const safe = this.resolveInside(params.path);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const tmp = `${safe}.${randomHex(4)}.tmp`;
+    try {
+      await fsp.writeFile(tmp, params.content, {
+        encoding: "utf8",
+        signal: controller.signal
+      });
+      await fsp.rename(tmp, safe);
+    } catch (err) {
+      try {
+        await fsp.unlink(tmp);
+      } catch {
+      }
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `writeTextFile timed out after ${this.timeoutMs}ms`);
+      }
+      throw mapFsError(err, safe);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Resolve a path; throw `FsError('OUTSIDE_ROOT')` if the result is
+   * not under the project root. Symlinks are not followed here — we
+   * operate on the textual path. A future hardening pass can
+   * `fs.realpath` each access to catch symlink escapes.
+   */
+  resolveInside(p) {
+    if (typeof p !== "string" || p.length === 0) {
+      throw new FsError("INVALID_PATH", p, "path is empty or not a string");
+    }
+    if (!path.isAbsolute(p)) {
+      throw new FsError("INVALID_PATH", p, "path must be absolute (ACP requirement)");
+    }
+    const resolved = path.resolve(p);
+    const rootWithSep = this.root.endsWith(path.sep) ? this.root : this.root + path.sep;
+    if (resolved !== this.root && !resolved.startsWith(rootWithSep)) {
+      throw new FsError("OUTSIDE_ROOT", resolved, "path is outside the project root");
+    }
+    return resolved;
+  }
+};
+function mapFsError(err, p) {
+  const code = err?.code;
+  if (code === "ENOENT") return new FsError("ENOENT", p, `no such file: ${p}`);
+  if (code === "EACCES" || code === "EPERM") {
+    return new FsError("EACCES", p, `permission denied: ${p}`);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return new FsError("INVALID_PATH", p, msg);
+}
+function randomHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes * 2; i++) {
+    out += Math.floor(Math.random() * 16).toString(16);
+  }
+  return out;
+}
+
+// src/client/permission.ts
+var defaultPermissionPolicy = async (req) => {
+  if (req.signal.aborted) return { outcome: "cancelled" };
+  const ranked = [...req.options].sort((a, b) => {
+    const score = (k) => {
+      if (k === "allow_always") return 0;
+      if (k === "allow_once") return 1;
+      if (k === "reject_once") return 2;
+      return 3;
+    };
+    return score(a.kind) - score(b.kind);
+  });
+  const chosen = ranked[0];
+  if (!chosen || chosen.kind === "reject_once" || chosen.kind === "reject_always") {
+    return { outcome: "cancelled" };
+  }
+  return { outcome: "selected", optionId: chosen.optionId };
+};
+var TerminalServer = class {
+  terminals = /* @__PURE__ */ new Map();
+  projectRoot;
+  commandTimeoutMs;
+  outputByteLimit;
+  nextId = 1;
+  constructor(opts) {
+    this.projectRoot = path.resolve(opts.projectRoot);
+    this.commandTimeoutMs = opts.commandTimeoutMs ?? 5 * 6e4;
+    this.outputByteLimit = opts.outputByteLimit ?? 1024 * 1024;
+    if (opts.signal) {
+      opts.signal.addEventListener("abort", () => this.releaseAll());
+    }
+  }
+  /** Spawn a new terminal. Returns the agent-facing id. */
+  create(params) {
+    const id = `term_${this.nextId++}`;
+    const cwd = this.resolveCwd(params.cwd);
+    const proc = spawn(params.command, params.args ?? [], {
+      cwd,
+      env: this.buildEnv(params.env),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+      // shell: false on purpose. The terminal server is invoked with
+      // the agent's explicit argv; turning on shell-mode would make
+      // the command a single shell-parsed string, which breaks
+      // Windows cmd quoting for the common case of running node with
+      // `-e "<script>"`. If a future feature needs shell features
+      // (pipes, redirects), it should be opt-in per-call, not the
+      // default.
+    });
+    const state = {
+      proc,
+      cwd,
+      command: params.command,
+      args: params.args ?? [],
+      output: "",
+      retainedBytes: 0,
+      truncated: false,
+      exitStatus: void 0,
+      timeoutHandle: null,
+      exitPromise: new Promise((resolve3) => {
+        proc.on("close", (code, signalName) => {
+          if (state.timeoutHandle) {
+            clearTimeout(state.timeoutHandle);
+            state.timeoutHandle = null;
+          }
+          const exitStatus = {
+            exitCode: typeof code === "number" ? code : null,
+            signal: typeof signalName === "string" ? signalName : null
+          };
+          state.exitStatus = exitStatus;
+          resolve3(exitStatus);
+        });
+        proc.on("error", (err) => {
+          if (state.timeoutHandle) {
+            clearTimeout(state.timeoutHandle);
+            state.timeoutHandle = null;
+          }
+          const exitStatus = { exitCode: 127, signal: null };
+          state.exitStatus = exitStatus;
+          state.output += `[spawn error] ${err.message}
+`;
+          state.retainedBytes += Buffer.byteLength(state.output, "utf8");
+          resolve3(exitStatus);
+        });
+      })
+    };
+    const perCallByteLimit = params.outputByteLimit ?? this.outputByteLimit;
+    proc.stdout?.setEncoding("utf8");
+    proc.stderr?.setEncoding("utf8");
+    const onData = (chunk) => {
+      state.output += chunk;
+      state.retainedBytes = Buffer.byteLength(state.output, "utf8");
+      while (state.retainedBytes > perCallByteLimit) {
+        const trimmed = state.output.slice(1);
+        state.output = trimmed;
+        const newBytes = Buffer.byteLength(state.output, "utf8");
+        if (newBytes >= state.retainedBytes) {
+          break;
+        }
+        state.retainedBytes = newBytes;
+        state.truncated = true;
+      }
+    };
+    proc.stdout?.on("data", onData);
+    proc.stderr?.on("data", onData);
+    state.timeoutHandle = setTimeout(() => {
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+    }, this.commandTimeoutMs);
+    this.terminals.set(id, state);
+    return { terminalId: id };
+  }
+  /** Return captured output and (if available) the exit status. */
+  output(terminalId) {
+    const state = this.terminals.get(terminalId);
+    if (!state) throw new Error(`unknown terminal: ${terminalId}`);
+    return {
+      output: state.output,
+      truncated: state.truncated,
+      ...state.exitStatus ? { exitStatus: state.exitStatus } : {}
+    };
+  }
+  /** Block until the process exits. Resolves with the exit status. */
+  async waitForExit(terminalId) {
+    const state = this.terminals.get(terminalId);
+    if (!state) throw new Error(`unknown terminal: ${terminalId}`);
+    return state.exitPromise;
+  }
+  /** Kill the process but keep the terminal record (agent can still read output). */
+  kill(terminalId) {
+    const state = this.terminals.get(terminalId);
+    if (!state) throw new Error(`unknown terminal: ${terminalId}`);
+    try {
+      state.proc.kill("SIGTERM");
+    } catch {
+    }
+  }
+  /** Kill the process if alive and remove the record. */
+  release(terminalId) {
+    const state = this.terminals.get(terminalId);
+    if (!state) return;
+    if (state.timeoutHandle) {
+      clearTimeout(state.timeoutHandle);
+      state.timeoutHandle = null;
+    }
+    try {
+      state.proc.kill("SIGKILL");
+    } catch {
+    }
+    this.terminals.delete(terminalId);
+  }
+  /** Kill all active terminals. Used on session close. */
+  releaseAll() {
+    for (const id of [...this.terminals.keys()]) {
+      this.release(id);
+    }
+  }
+  resolveCwd(cwd) {
+    if (!cwd) return this.projectRoot;
+    const resolved = path.resolve(cwd);
+    const rootWithSep = this.projectRoot.endsWith(path.sep) ? this.projectRoot : this.projectRoot + path.sep;
+    if (resolved !== this.projectRoot && !resolved.startsWith(rootWithSep)) {
+      return this.projectRoot;
+    }
+    return resolved;
+  }
+  buildEnv(agentEnv) {
+    const env = { ...process.env };
+    if (process.platform === "win32") {
+      if (env.Path !== void 0 && env.PATH === void 0) env.PATH = env.Path;
+      if (env.PATHEXT !== void 0 && env.PATHEXT_CASE === void 0) {
+        env.PATHEXT_CASE = env.PATHEXT;
+      }
+    }
+    if (agentEnv) {
+      for (const { name, value } of agentEnv) {
+        env[name] = value;
+      }
+    }
+    return env;
+  }
+};
+
+// src/client/acp-session.ts
+var ACPSessionError = class extends Error {
+  kind;
+  cause;
+  constructor(kind, message, cause) {
+    super(message);
+    this.name = "ACPSessionError";
+    this.kind = kind;
+    this.cause = cause;
+  }
+};
+function isJsonRpcError(v) {
+  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
+}
+var ACPSession = class _ACPSession {
+  transport;
+  fileServer;
+  terminalServer;
+  permissionPolicy;
+  timeoutMs;
+  opts;
+  state = "init";
+  sessionId = null;
+  /** Pending outbound requests (initialize, session/new, session/prompt, etc). */
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  /** True after close() has been called. */
+  closed = false;
+  constructor(opts, transport) {
+    this.opts = opts;
+    this.transport = transport;
+    this.timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+    const fsOpts = {
+      projectRoot: opts.projectRoot
+    };
+    if (opts.fsTimeoutMs !== void 0) fsOpts.timeoutMs = opts.fsTimeoutMs;
+    this.fileServer = new FileServer(fsOpts);
+    const termOpts = {
+      projectRoot: opts.projectRoot
+    };
+    if (opts.terminalTimeoutMs !== void 0) {
+      termOpts.commandTimeoutMs = opts.terminalTimeoutMs;
+    }
+    if (opts.terminalOutputByteLimit !== void 0) {
+      termOpts.outputByteLimit = opts.terminalOutputByteLimit;
+    }
+    this.terminalServer = new TerminalServer(termOpts);
+    this.permissionPolicy = opts.permissionPolicy ?? defaultPermissionPolicy;
+  }
+  /**
+   * Spawn the child, run the initialize handshake, install the
+   * message dispatch, and return a ready session.
+   */
+  static async start(opts) {
+    const transportOpts = {
+      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);
+    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);
+    }
+    const session = new _ACPSession(opts, transport);
+    transport.onMessage((msg) => session.handleMessage(msg));
+    try {
+      await session.initialize();
+    } catch (err) {
+      try {
+        transport.stop();
+      } catch {
+      }
+      throw err;
+    }
+    return session;
+  }
+  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 }
+      },
+      clientInfo: { name: "wrongstack", title: "WrongStack", version: "0.263.0" }
+    });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError("init_failed", `initialize failed: ${result.message}`, result);
+    }
+    if (typeof result !== "object" || result === null || typeof result.protocolVersion !== "number") {
+      throw new ACPSessionError("protocol_error", "initialize returned no protocolVersion");
+    }
+    const r = result;
+    if (r.protocolVersion !== ACP_PROTOCOL_VERSION) {
+      throw new ACPSessionError(
+        "unsupported_capability",
+        `agent speaks protocolVersion=${r.protocolVersion}, client speaks ${ACP_PROTOCOL_VERSION}`
+      );
+    }
+    this.state = "ready";
+  }
+  /**
+   * Run one prompt turn. Creates a session if needed, sends the
+   * prompt, streams session/update notifications, and resolves with
+   * the agent's response.
+   *
+   * 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) {
+    if (this.closed) {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    if (this.state !== "ready" && this.state !== "done") {
+      throw new ACPSessionError("protocol_error", `prompt called in state=${this.state}`);
+    }
+    if (signal.aborted) {
+      return { text: "", stopReason: "cancelled", hasText: false };
+    }
+    if (!this.sessionId) {
+      await this.createSession();
+    }
+    this.resetScratch();
+    const promptId = this.allocId();
+    const turnPromise = this.sendRequest(
+      promptId,
+      "session/prompt",
+      {
+        sessionId: this.sessionId,
+        prompt: [textContent(text)]
+      },
+      this.timeoutMs
+    );
+    let cancelled = false;
+    const onAbort = () => {
+      cancelled = true;
+      this.transport.send({ method: "session/cancel", params: { sessionId: this.sessionId } }).catch(() => {
+      });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    this.state = "prompting";
+    let response;
+    try {
+      response = await turnPromise;
+    } catch (err) {
+      this.state = "done";
+      signal.removeEventListener("abort", onAbort);
+      if (cancelled || signal.aborted) {
+        throw new ACPSessionError("aborted", "prompt was aborted by the parent");
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new ACPSessionError("prompt_failed", `session/prompt failed: ${msg}`, err);
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+    }
+    this.state = "done";
+    if (isJsonRpcError(response)) {
+      throw new ACPSessionError("prompt_failed", `agent error: ${response.message}`, response);
+    }
+    const stopReason = response.stopReason ?? "end_turn";
+    const finalText = this.scratch.text;
+    return {
+      text: finalText,
+      stopReason,
+      hasText: finalText.length > 0,
+      usage: this.scratch.usage,
+      plan: this.scratch.plan
+    };
+  }
+  async createSession() {
+    const id = this.allocId();
+    const result = await this.sendRequest(id, "session/new", {
+      cwd: this.opts.cwd ?? this.opts.projectRoot,
+      mcpServers: []
+    });
+    if (isJsonRpcError(result)) {
+      throw new ACPSessionError(
+        "session_create_failed",
+        `session/new failed: ${result.message}`,
+        result
+      );
+    }
+    const sessionId = result.sessionId;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new ACPSessionError(
+        "protocol_error",
+        "session/new returned no sessionId",
+        result
+      );
+    }
+    this.sessionId = sessionId;
+  }
+  /** Tear down the session and kill the child process. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.state = "closed";
+    this.terminalServer.releaseAll();
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timeoutHandle);
+      p.reject(new ACPSessionError("closed", "session was closed"));
+    }
+    this.pending.clear();
+    try {
+      this.transport.stop();
+    } catch {
+    }
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // Wire layer
+  // ────────────────────────────────────────────────────────────────────
+  allocId() {
+    return this.nextId++;
+  }
+  async sendRequest(id, method, params, timeoutMs) {
+    return new Promise((resolve3, reject) => {
+      const effectiveTimeout = timeoutMs ?? this.timeoutMs;
+      const handle = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new ACPSessionError(
+            "protocol_error",
+            `${method} timed out after ${effectiveTimeout}ms`
+          )
+        );
+      }, effectiveTimeout);
+      this.pending.set(id, {
+        method,
+        resolve: resolve3,
+        reject,
+        timeoutMs: effectiveTimeout,
+        timeoutHandle: handle
+      });
+      this.transport.send({ jsonrpc: "2.0", id, method, params }).catch((err) => {
+        clearTimeout(handle);
+        this.pending.delete(id);
+        const msg = err instanceof Error ? err.message : String(err);
+        reject(new ACPSessionError("protocol_error", `send ${method} failed: ${msg}`, err));
+      });
+    });
+  }
+  handleMessage(msg) {
+    if (msg.id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      clearTimeout(pending.timeoutHandle);
+      this.pending.delete(msg.id);
+      if (msg.error !== void 0) {
+        pending.reject(new Error(msg.error.message ?? "unknown JSON-RPC error"));
+      } else {
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    if (msg.method === "session/update") {
+      this.handleUpdate(msg);
+      return;
+    }
+    if (msg.method === "session/request_permission") {
+      void this.handlePermissionRequest(msg);
+      return;
+    }
+    if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
+      void this.handleFsRequest(msg);
+      return;
+    }
+    if (msg.method && msg.method.startsWith("terminal/")) {
+      void this.handleTerminalRequest(msg);
+      return;
+    }
+    if (msg.method) {
+      console.warn(`[acp-session] unhandled method: ${msg.method}`);
+    }
+  }
+  handleUpdate(msg) {
+    const update = msg.params?.update;
+    if (typeof update !== "object" || update === null) return;
+    const u = update;
+    switch (u.sessionUpdate) {
+      case "agent_message_chunk": {
+        const text = extractText(u.content);
+        if (text) this.accumulatedText(text);
+        return;
+      }
+      case "thought_chunk":
+        return;
+      case "tool_call":
+      case "tool_call_update":
+        return;
+      case "plan":
+        if (Array.isArray(u.entries)) {
+          this.accumulatedPlan(u.entries);
+        }
+        return;
+      case "usage_update":
+        if (typeof u.used === "number" && typeof u.size === "number") {
+          this.accumulatedUsage({
+            used: u.used,
+            size: u.size,
+            ...typeof u.cost === "object" && u.cost !== null ? {
+              cost: u.cost
+            } : {}
+          });
+        }
+        return;
+      case "available_commands_update":
+      case "current_mode_update":
+      case "config_option_update":
+      case "session_info_update":
+      case "user_message_chunk":
+        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;
+  }
+  accumulatedUsage(u) {
+    this.scratch.usage = u;
+  }
+  resetScratch() {
+    this.scratch = { text: "" };
+  }
+  async handlePermissionRequest(msg) {
+    const id = msg.id;
+    if (id === void 0) return;
+    const params = msg.params;
+    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" }
+      });
+      return;
+    }
+    const policyAbort = new AbortController();
+    const outcome = await this.permissionPolicy({
+      toolCall,
+      options,
+      signal: policyAbort.signal
+    });
+    await this.transport.send({
+      id,
+      method: "session/request_permission",
+      result: { 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" }
+      });
+      return;
+    }
+    try {
+      if (msg.method === "fs/read_text_file") {
+        const result = await this.fileServer.readTextFile({
+          sessionId: params.sessionId ?? "",
+          path: params.path
+        });
+        await this.transport.send({ id, method: msg.method, result });
+      } else {
+        await this.fileServer.writeTextFile({
+          sessionId: params.sessionId ?? "",
+          path: params.path,
+          content: params.content ?? ""
+        });
+        await this.transport.send({ id, method: msg.method, result: {} });
+      }
+    } 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 } });
+    }
+  }
+  async handleTerminalRequest(msg) {
+    const id = msg.id;
+    if (id === void 0) return;
+    const params = msg.params ?? {};
+    try {
+      switch (msg.method) {
+        case "terminal/create": {
+          const createOpts = {
+            sessionId: String(params.sessionId ?? ""),
+            command: String(params.command ?? ""),
+            args: Array.isArray(params.args) ? params.args : []
+          };
+          if (Array.isArray(params.env)) {
+            createOpts.env = params.env;
+          }
+          if (typeof params.cwd === "string") {
+            createOpts.cwd = params.cwd;
+          }
+          if (typeof params.outputByteLimit === "number") {
+            createOpts.outputByteLimit = params.outputByteLimit;
+          }
+          const result = this.terminalServer.create(createOpts);
+          await this.transport.send({ id, method: msg.method, 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 });
+          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 });
+          return;
+        }
+        case "terminal/kill": {
+          const terminalId = String(params.terminalId ?? "");
+          this.terminalServer.kill(terminalId);
+          await this.transport.send({ id, method: msg.method, result: {} });
+          return;
+        }
+        case "terminal/release": {
+          const terminalId = String(params.terminalId ?? "");
+          this.terminalServer.release(terminalId);
+          await this.transport.send({ id, method: msg.method, result: {} });
+          return;
+        }
+        default:
+          await this.transport.send({
+            id,
+            method: msg.method,
+            error: { code: -32601, message: `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 }
+      });
+    }
+  }
+};
+function textContent(text) {
+  return { type: "text", text };
+}
+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 = {
@@ -659,182 +1604,644 @@ var ACP_AGENT_COMMANDS = {
   }
 };
 async function makeACPSubagentRunner(options) {
-  const transport = new ClientTransport(clientTransportOptions(options));
-  const translator = new ToolTranslator(options.toolTranslatorOpts);
-  const activeAbort = new AbortController();
-  let sessionStarted = false;
-  const startSession = async () => {
-    if (sessionStarted) return;
-    await transport.start();
-    await transport.send({
-      method: "initialize",
-      id: "1",
-      params: {
-        capabilities: ["code-generation", "async-tools", "streaming", "progress"],
-        protocolVersion: "2024-11",
-        sessionId: options.role ?? "wrongstack-subagent"
-      }
-    });
-    const initResp = await transport.read();
-    if (!initResp || initResp.error) {
-      throw new Error(`ACP initialize failed: ${initResp?.error?.message ?? "no response"}`);
+  const { runner, stop } = await makeACPSubagentRunnerWithStop(options);
+  const wrappedRunner = async (task, ctx) => {
+    try {
+      return await runner(task, ctx);
+    } finally {
+      stop();
     }
-    translator.attachToTransport({
-      onMessage: (h) => transport.onMessage(h),
-      send: (m) => transport.send(m)
-    });
-    sessionStarted = true;
   };
+  return wrappedRunner;
+}
+async function makeACPSubagentRunnerWithStop(options) {
+  const projectRoot = options.projectRoot ?? options.cwd ?? process.cwd();
+  const timeoutMs = options.timeoutMs ?? 5 * 6e4;
   const runner = async (task, ctx) => {
-    ctx.signal.addEventListener("abort", () => {
-      activeAbort.abort();
-      transport.stop();
-    });
-    await startSession();
-    const callId = crypto.randomUUID();
-    let toolResult = null;
-    const resultPromise = new Promise((resolve, reject) => {
-      const budgetMs = ctx.budget.limits.timeoutMs ?? 3e5;
-      const timeout = setTimeout(() => {
-        reject(new Error(`ACP task timed out for subagent ${ctx.subagentId} (${budgetMs}ms budget)`));
-      }, budgetMs);
-      transport.onMessage((msg) => {
-        if (msg.method === "tools/call" && msg.id !== void 0) {
-          clearTimeout(timeout);
-          resolve(msg);
-        }
-      });
-      ctx.signal.addEventListener("abort", () => {
-        clearTimeout(timeout);
-        reject(new Error("Task aborted by parent"));
-      });
-    });
+    let session = null;
     try {
-      await transport.send({
-        method: "agent/run",
-        id: callId,
-        params: {
-          task: task.description,
-          sessionId: ctx.subagentId
-        }
+      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
       });
-      toolResult = await resultPromise;
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      throw acpErrorToSubagentError(err, options.role ?? "acp-subagent");
+    }
+    try {
+      const result = await session.prompt(task.description, ctx.signal);
       return {
-        result: `ACP subagent error: ${msg}`,
-        iterations: 0,
+        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 {
+      }
     }
-    if (!toolResult) {
-      return { result: "ACP subagent returned no result", iterations: 1, toolCalls: 1 };
-    }
-    const parsed = parseToolResponse(task.id, ctx.subagentId, toolResult);
+  };
+  const stop = () => {
+  };
+  return { runner, stop };
+}
+function acpErrorToSubagentError(err, subagentId) {
+  if (err instanceof ACPSessionError) {
+    const kind = mapACPKind(err.kind);
     return {
-      result: parsed.result ?? parsed.error,
-      iterations: parsed.iterations,
-      toolCalls: parsed.toolCalls
+      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 } : {}
+    }
   };
-  return runner;
 }
-async function makeACPSubagentRunnerWithStop(options) {
-  const transport = new ClientTransport(clientTransportOptions(options));
-  const translator = new ToolTranslator(options.toolTranslatorOpts);
-  const activeAbort = new AbortController();
-  let sessionStarted = false;
-  const startSession = async () => {
-    if (sessionStarted) return;
-    await transport.start();
-    await transport.send({
-      method: "initialize",
-      id: "1",
-      params: {
-        capabilities: ["code-generation", "async-tools", "streaming", "progress"],
-        protocolVersion: "2024-11",
-        sessionId: options.role ?? "wrongstack-subagent"
+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 = [
+  // ── Anthropic ────────────────────────────────────────────────────────
+  {
+    id: "claude-code",
+    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: [] },
+    supports: {
+      loadSession: true,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "adapter",
+    docs: "https://docs.anthropic.com/en/docs/claude-code"
+  },
+  // ── Google ───────────────────────────────────────────────────────────
+  {
+    id: "gemini-cli",
+    displayName: "Gemini CLI",
+    vendor: "google",
+    probe: { command: "gemini", args: ["--version"] },
+    acp: { command: "gemini", args: [] },
+    supports: {
+      loadSession: true,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "native",
+    docs: "https://github.com/google-gemini/gemini-cli"
+  },
+  // ── OpenAI ───────────────────────────────────────────────────────────
+  {
+    id: "codex-cli",
+    displayName: "Codex CLI",
+    vendor: "openai",
+    probe: { command: "codex", args: ["--version"] },
+    acp: { command: "codex", args: [] },
+    supports: {
+      loadSession: false,
+      promptImages: false,
+      terminal: true,
+      fs: true
+    },
+    integration: "adapter",
+    docs: "https://github.com/openai/codex"
+  },
+  // ── GitHub ───────────────────────────────────────────────────────────
+  {
+    id: "copilot",
+    displayName: "GitHub Copilot CLI",
+    vendor: "github",
+    probe: { command: "gh", args: ["copilot", "--help"] },
+    acp: { command: "gh", args: ["copilot"] },
+    supports: {
+      loadSession: false,
+      promptImages: false,
+      terminal: true,
+      fs: false
+    },
+    integration: "experimental",
+    docs: "https://github.com/features/copilot/cli"
+  },
+  // ── Community / wrappers ─────────────────────────────────────────────
+  {
+    id: "cline",
+    displayName: "Cline",
+    vendor: "community",
+    probe: { command: "npx", args: ["--version"] },
+    acp: {
+      command: "npx",
+      args: ["-y", "@agentify/cline"]
+    },
+    supports: {
+      loadSession: true,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "community",
+    docs: "https://github.com/cline/cline"
+  },
+  {
+    id: "goose",
+    displayName: "Goose",
+    vendor: "community",
+    probe: { command: "goose", args: ["--version"] },
+    acp: { command: "goose", args: [] },
+    supports: {
+      loadSession: true,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "experimental",
+    docs: "https://github.com/block/goose"
+  },
+  {
+    id: "openhands",
+    displayName: "OpenHands",
+    vendor: "community",
+    probe: { command: "openhands", args: ["--version"] },
+    acp: { command: "openhands", args: [] },
+    supports: {
+      loadSession: false,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "experimental",
+    docs: "https://github.com/All-Hands-AI/OpenHands"
+  },
+  // ── Vendor CLIs (native binaries) ───────────────────────────────────
+  {
+    id: "qwen-code",
+    displayName: "Qwen Code",
+    vendor: "community",
+    probe: { command: "qwen", args: ["--version"] },
+    acp: { command: "qwen", args: [] },
+    supports: {
+      loadSession: false,
+      promptImages: false,
+      terminal: true,
+      fs: false
+    },
+    integration: "experimental",
+    docs: "https://github.com/QwenLM/Qwen3-Coder"
+  },
+  {
+    id: "kiro-cli",
+    displayName: "Kiro CLI",
+    vendor: "community",
+    probe: { command: "kiro", args: ["--version"] },
+    acp: { command: "kiro", args: [] },
+    supports: {
+      loadSession: false,
+      promptImages: false,
+      terminal: true,
+      fs: true
+    },
+    integration: "experimental",
+    docs: "https://kiro.dev"
+  },
+  {
+    id: "opencode",
+    displayName: "OpenCode",
+    vendor: "community",
+    probe: { command: "opencode", args: ["--version"] },
+    acp: { command: "opencode", args: [] },
+    supports: {
+      loadSession: true,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "native",
+    docs: "https://github.com/sst/opencode"
+  },
+  {
+    id: "mistral-vibe",
+    displayName: "Mistral Vibe",
+    vendor: "community",
+    probe: { command: "vibe", args: ["--version"] },
+    acp: { command: "vibe", args: [] },
+    supports: {
+      loadSession: false,
+      promptImages: false,
+      terminal: true,
+      fs: false
+    },
+    integration: "experimental",
+    docs: "https://github.com/mistralai/mistral-vibe"
+  },
+  {
+    id: "cursor",
+    displayName: "Cursor",
+    vendor: "community",
+    probe: { command: "cursor", args: ["--version"] },
+    acp: { command: "cursor", args: [] },
+    supports: {
+      loadSession: true,
+      promptImages: true,
+      terminal: true,
+      fs: true
+    },
+    integration: "experimental",
+    docs: "https://cursor.com"
+  }
+];
+function findAgentDescriptor(id) {
+  return AGENTS_CATALOG.find((a) => a.id === id);
+}
+var PROBE_TIMEOUT_MS = 5e3;
+var PROBE_CACHE_MS = 5e3;
+async function defaultProbe(desc, timeoutMs) {
+  const start = Date.now();
+  return new Promise((resolve3) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      try {
+        child.kill();
+      } catch {
       }
-    });
-    const initResp = await transport.read();
-    if (!initResp || initResp.error) {
-      throw new Error(`ACP initialize failed: ${initResp?.error?.message ?? "no response"}`);
+      resolve3(result);
+    };
+    let child;
+    try {
+      child = spawn(desc.probe.command, [...desc.probe.args ?? []], {
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        // On Windows, `claude`, `gemini`, `npx`, etc. are typically
+        // installed as `.cmd` shims under AppData\Roaming\npm\. Node's
+        // spawn() will not find them without shell-mode unless the
+        // extension is present. `shell: true` resolves this for the
+        // common case. The probe argv is always from our static
+        // catalog, never user input, so shell-expansion is bounded.
+        shell: process.platform === "win32"
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      finish({ ok: false, reason: `spawn failed: ${msg}`, durationMs: 0 });
+      return;
     }
-    translator.attachToTransport({
-      onMessage: (h) => transport.onMessage(h),
-      send: (m) => transport.send(m)
+    const timer = setTimeout(() => {
+      finish({ ok: false, reason: "probe timed out", durationMs: Date.now() - start });
+    }, timeoutMs);
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
     });
-    sessionStarted = true;
-  };
-  const stop = () => {
-    activeAbort.abort();
-    transport.stop();
-  };
-  const runner = async (task, ctx) => {
-    ctx.signal.addEventListener("abort", () => {
-      activeAbort.abort();
-      transport.stop();
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
     });
-    await startSession();
-    const callId = crypto.randomUUID();
-    let toolResult = null;
-    const resultPromise = new Promise((resolve, reject) => {
-      const budgetMs = ctx.budget.limits.timeoutMs ?? 3e5;
-      const timeout = setTimeout(() => {
-        reject(new Error(`ACP task timed out for subagent ${ctx.subagentId} (${budgetMs}ms budget)`));
-      }, budgetMs);
-      transport.onMessage((msg) => {
-        if (msg.method === "tools/call" && msg.id !== void 0) {
-          clearTimeout(timeout);
-          resolve(msg);
-        }
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      finish({
+        ok: false,
+        reason: `binary not found: ${err.message}`,
+        durationMs: Date.now() - start
       });
-      ctx.signal.addEventListener("abort", () => {
-        clearTimeout(timeout);
-        reject(new Error("Task aborted by parent"));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - start;
+      const out = (stdout + stderr).trim();
+      const isWindowsShellMiss = process.platform === "win32" && out.toLowerCase().includes("is not recognized");
+      if (isWindowsShellMiss) {
+        finish({
+          ok: false,
+          reason: "binary not found",
+          durationMs
+        });
+        return;
+      }
+      if (out.length > 0) {
+        finish({
+          ok: true,
+          version: out.split("\n")[0]?.trim() ?? "",
+          path: desc.probe.command,
+          durationMs
+        });
+        return;
+      }
+      finish({
+        ok: false,
+        reason: `exit code ${code ?? "null"}; no output`,
+        durationMs
       });
     });
+  });
+}
+var EnsembleRegistry = class {
+  catalog;
+  timeoutMs;
+  probe;
+  cache = null;
+  constructor(options = {}) {
+    this.catalog = options.catalog ?? AGENTS_CATALOG;
+    this.timeoutMs = options.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
+    this.probe = options.probeFn ?? ((d) => defaultProbe(d, this.timeoutMs));
+  }
+  /** Return the full catalog (no probe), in catalog order. */
+  listAll() {
+    return this.catalog;
+  }
+  /**
+   * Probe every catalog entry in parallel and return the detection
+   * results. Results are cached for `PROBE_CACHE_MS`.
+   */
+  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))
+    );
+    this.cache = { at: Date.now(), result };
+    return result;
+  }
+  /** Probe a single descriptor. Always returns a `DetectedAgent`. */
+  async detect(desc) {
+    const result = await this.probe(desc);
+    if (result.ok) {
+      const detected = {
+        ...desc,
+        installed: true,
+        version: result.version
+      };
+      if (result.path !== void 0) detected.path = result.path;
+      return detected;
+    }
+    return { ...desc, installed: false, reason: result.reason };
+  }
+  /** Invalidate the per-process cache. */
+  invalidate() {
+    this.cache = null;
+  }
+  /** Convenience: just the installed agents. */
+  async listInstalled() {
+    const all = await this.list();
+    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
+  };
+  if (desc.acp.env) out.env = desc.acp.env;
+  return out;
+};
+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) {
+  const startedAt = Date.now();
+  try {
+    const { runner, stop } = await makeACPSubagentRunnerWithStop({
+      ...cmd,
+      timeoutMs
+    });
     try {
-      await transport.send({
-        method: "agent/run",
-        id: callId,
-        params: {
-          task: task.description,
-          sessionId: ctx.subagentId
-        }
+      const budget = new SubagentBudget({
+        timeoutMs,
+        maxIterations: 2e3,
+        maxToolCalls: 5e3
       });
-      toolResult = await resultPromise;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const result = await runner(
+        { id: `ensemble-${agentId}`, description: task },
+        {
+          subagentId: agentId,
+          config: {
+            id: agentId,
+            name: agentId,
+            role: agentId,
+            provider: "acp",
+            prompt: ""
+          },
+          budget,
+          signal: signal ?? new AbortController().signal,
+          bridge: null
+        }
+      );
       return {
-        result: `ACP subagent error: ${msg}`,
-        iterations: 0,
-        toolCalls: 0
+        status: "success",
+        result: result.result == null ? "" : String(result.result),
+        durationMs: Date.now() - startedAt,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls
       };
+    } finally {
+      try {
+        stop();
+      } catch {
+      }
     }
-    if (!toolResult) {
-      return { result: "ACP subagent returned no result", iterations: 1, toolCalls: 1 };
-    }
-    const parsed = parseToolResponse(task.id, ctx.subagentId, toolResult);
+  } catch (err) {
+    const e = err;
+    const isAbort = e?.name === "AbortError" || e?.kind === "aborted" || e?.kind === "aborted_by_parent" || e?.message?.toLowerCase().includes("aborted");
     return {
-      result: parsed.result ?? parsed.error,
-      iterations: parsed.iterations,
-      toolCalls: parsed.toolCalls
+      status: isAbort ? "cancelled" : "failed",
+      error: {
+        kind: e?.kind ?? (isAbort ? "aborted" : "unknown"),
+        message: e?.message ?? (err instanceof Error ? err.message : String(err))
+      },
+      durationMs: Date.now() - startedAt,
+      iterations: 0,
+      toolCalls: 0
     };
-  };
-  return { runner, stop };
+  }
 }
-function clientTransportOptions(options) {
-  const out = {
-    command: options.command,
-    handshakeTimeoutMs: 3e4
+async function runEnsemble(opts) {
+  const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+  const registry = opts.registry ?? new EnsembleRegistry();
+  const resolveCmd = opts.resolveCmd ?? defaultEnsembleCmdResolver;
+  const seen = /* @__PURE__ */ new Set();
+  const requested = [];
+  for (const raw of opts.agentIds.split(",")) {
+    const id = raw.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    requested.push(id);
+  }
+  const results = requested.map((agentId) => ({
+    agentId,
+    status: "skipped",
+    durationMs: 0,
+    iterations: 0,
+    toolCalls: 0
+  }));
+  const startMs = Date.now();
+  if (requested.length === 0) {
+    return {
+      task: opts.task,
+      requested,
+      results,
+      summary: { succeeded: 0, failed: 0, skipped: 0, cancelled: 0 },
+      totalDurationMs: 0
+    };
+  }
+  const detected = await registry.list();
+  const detectedById = new Map(detected.map((a) => [a.id, a]));
+  const runnable = [];
+  for (const id of requested) {
+    const det = detectedById.get(id);
+    if (!det || !det.installed) {
+      setResult(results, id, {
+        status: "skipped",
+        reason: det?.reason ?? "not in catalog"
+      });
+      continue;
+    }
+    const cmd = resolveCmd(id);
+    if (!cmd) {
+      setResult(results, id, {
+        status: "failed",
+        error: { kind: "unknown_agent", message: `Unknown ACP agent: ${id}` },
+        durationMs: 0
+      });
+      continue;
+    }
+    runnable.push({ id, cmd });
+  }
+  await Promise.allSettled(
+    runnable.map(async ({ id, cmd }) => {
+      if (opts.signal?.aborted) {
+        setResult(results, id, {
+          status: "cancelled",
+          error: { kind: "aborted", message: "aborted by parent" },
+          durationMs: 0
+        });
+        return;
+      }
+      const outcome = await runOne(id, cmd, opts.task, timeoutMs, opts.signal);
+      setResult(results, id, outcome);
+    })
+  );
+  const summary = { succeeded: 0, failed: 0, skipped: 0, cancelled: 0 };
+  for (const r of results) {
+    if (r.status === "success") summary.succeeded++;
+    else if (r.status === "failed") summary.failed++;
+    else if (r.status === "cancelled") summary.cancelled++;
+    else summary.skipped++;
+  }
+  return {
+    task: opts.task,
+    requested,
+    results,
+    summary,
+    totalDurationMs: Date.now() - startMs
   };
-  if (options.args !== void 0) out.args = options.args;
-  if (options.env !== void 0) out.env = options.env;
-  if (options.cwd !== void 0) out.cwd = options.cwd;
-  return out;
+}
+function renderEnsembleText(result) {
+  const lines = [];
+  if (result.requested.length === 0) {
+    lines.push("No agent ids provided.");
+    return lines.join("\n");
+  }
+  for (const r of result.results) {
+    lines.push(`
+=== ${r.agentId} ===`);
+    switch (r.status) {
+      case "success":
+        lines.push(r.result && r.result.length > 0 ? r.result : "(no result)");
+        lines.push(
+          `[${r.agentId}] success  ${r.durationMs}ms  iterations=${r.iterations} toolCalls=${r.toolCalls}`
+        );
+        break;
+      case "failed":
+        lines.push(
+          `[${r.error?.kind ?? "unknown"}] ${r.error?.message ?? "failed"}`
+        );
+        lines.push(`[${r.agentId}] failed  ${r.durationMs}ms`);
+        break;
+      case "cancelled":
+        lines.push(
+          `[${r.error?.kind ?? "aborted"}] ${r.error?.message ?? "cancelled"}`
+        );
+        lines.push(`[${r.agentId}] cancelled  ${r.durationMs}ms`);
+        break;
+      case "skipped":
+        lines.push(`(skipped \u2014 ${r.reason ?? "not installed"})`);
+        break;
+    }
+  }
+  const { succeeded, failed, skipped, cancelled } = result.summary;
+  lines.push(
+    `
+Ensemble summary: ${succeeded} succeeded, ${failed} failed, ${cancelled} cancelled, ${skipped} skipped. (${result.totalDurationMs}ms total)`
+  );
+  return lines.join("\n");
 }
 
-export { ACPProtocolHandler, ACPToolsRegistry, ACP_AGENT_COMMANDS, ClientTransport, StdioTransport, ToolTranslator, WrongStackACPServer, makeACPSubagentRunner, makeACPSubagentRunnerWithStop };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map