@wrongstack/acp 0.274.0 → 0.275.1

package/dist/sdk.js

@@ -0,0 +1,3350 @@
+export { AGENT_METHODS, ActiveSession, AgentApp, CLIENT_METHODS, ClientApp, PROTOCOL_METHODS, PROTOCOL_VERSION, SessionBuilder, methods } from '@agentclientprotocol/sdk';
+export { AcpServer } from '@agentclientprotocol/sdk/experimental/server';
+export { createWebSocketStream } from '@agentclientprotocol/sdk/experimental/ws-client';
+export { createNodeHttpHandler, createNodeWebSocketUpgradeHandler } from '@agentclientprotocol/sdk/experimental/node';
+import { writeErr, expectDefined } from '@wrongstack/core';
+import * as fsp2 from 'fs/promises';
+import * as path3 from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { createServer } from 'http';
+import { SubagentBudget } from '@wrongstack/core/coordination';
+
+// src/sdk.ts
+var StdioTransport = class {
+  stdin = process.stdin;
+  stdout = process.stdout;
+  stderr = process.stderr;
+  buffer = "";
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  resolveRead = null;
+  messageQueue = [];
+  constructor() {
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("data", (chunk) => this.onData(chunk));
+    this.stdin.on("end", () => this.handleClose());
+    this.stdin.on("error", (err) => this.failAll(err));
+  }
+  sendStartupMarker() {
+    this.stdout.write("[wstack-acp]\n", "utf8");
+  }
+  send(msg) {
+    if (this.closed) return Promise.resolve();
+    return new Promise((resolve3) => {
+      const line = JSON.stringify(msg) + "\n";
+      this.stdout.write(line, "utf8", () => resolve3());
+    });
+  }
+  sendRaw(chunk) {
+    this.stdout.write(chunk, "utf8");
+  }
+  read() {
+    if (this.messageQueue.length > 0) return Promise.resolve(expectDefined(this.messageQueue.shift()));
+    if (this.closed) return Promise.resolve(null);
+    return new Promise((resolve3) => {
+      this.resolveRead = resolve3;
+    });
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  close() {
+    this.closed = true;
+    this.stdin.pause();
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const raw of lines) {
+      if (!raw.trim()) continue;
+      try {
+        this.dispatch(JSON.parse(raw));
+      } catch (err) {
+        this.stderr.write(`[wstack-acp parse error] ${err}
+`, "utf8");
+      }
+    }
+  }
+  dispatch(msg) {
+    if (this.resolveRead) {
+      const resolve3 = this.resolveRead;
+      this.resolveRead = null;
+      resolve3(msg);
+    } else {
+      this.messageQueue.push(msg);
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(msg);
+      } catch (err) {
+        this.stderr.write(`[wstack-acp handler error] ${err}
+`, "utf8");
+      }
+    }
+  }
+  handleClose() {
+    this.closed = true;
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+  }
+  failAll(err) {
+    this.stderr.write(`[wstack-acp stdin error] ${err.message}
+`, "utf8");
+    this.close();
+  }
+};
+var ClientTransport = class {
+  child = null;
+  buffer = "";
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  resolveRead = null;
+  messageQueue = [];
+  opts;
+  constructor(options) {
+    this.opts = {
+      handshakeTimeoutMs: 3e4,
+      ...options
+    };
+  }
+  async start() {
+    if (this.child) return;
+    const [{ spawn: spawn2 }, { buildChildEnv }, os] = await Promise.all([
+      import('child_process'),
+      import('@wrongstack/core'),
+      import('os')
+    ]);
+    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);
+      const isPkgLauncher = this.opts.command === "npx" || this.opts.command === "uvx";
+      const spawnCwd = isPkgLauncher ? os.homedir() : this.opts.cwd;
+      try {
+        this.child = spawn2(this.opts.command, this.opts.args ?? [], {
+          env: { ...buildChildEnv(), ...this.opts.env },
+          cwd: spawnCwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          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);
+        reject(err);
+        return;
+      }
+      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();
+      };
+      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);
+          onReady();
+        }
+      };
+      child.stdout.on("data", waitForMarker);
+    });
+  }
+  send(msg) {
+    if (!this.child) return Promise.reject(new Error("ClientTransport not started"));
+    return new Promise((resolve3, reject) => {
+      const line = JSON.stringify(msg) + "\n";
+      this.child?.stdin.write(line, "utf8", (err) => {
+        if (err) reject(err);
+        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((resolve3) => {
+      this.resolveRead = resolve3;
+    });
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  stop() {
+    if (!this.child) return;
+    this.closed = true;
+    try {
+      this.child.kill();
+    } catch {
+    }
+    this.child = null;
+  }
+  onChildData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const raw of lines) {
+      if (!raw.trim()) continue;
+      try {
+        this.dispatch(JSON.parse(raw));
+      } catch {
+      }
+    }
+  }
+  onChildError(chunk) {
+    writeErr(`[acp-child stderr] ${chunk}`);
+  }
+  onChildClose(code) {
+    this.closed = true;
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+    if (code !== 0 && code !== null) {
+      writeErr(`[acp-child exited with code ${code}]
+`);
+    }
+  }
+  dispatch(msg) {
+    if (this.resolveRead) {
+      const resolve3 = this.resolveRead;
+      this.resolveRead = null;
+      resolve3(msg);
+    } else {
+      this.messageQueue.push(msg);
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(msg);
+      } catch {
+      }
+    }
+  }
+};
+
+// 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 {
+      }
+    }
+  }
+};
+
+// src/types/acp-v1.ts
+var ACP_PROTOCOL_VERSION = 1;
+var FsError = class extends Error {
+  code;
+  path;
+  constructor(code, path4, message) {
+    super(message);
+    this.name = "FsError";
+    this.code = code;
+    this.path = path4;
+  }
+};
+var FileServer = class {
+  root;
+  timeoutMs;
+  constructor(opts) {
+    this.root = path3.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 fsp2.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 fsp2.writeFile(tmp, params.content, {
+        encoding: "utf8",
+        signal: controller.signal
+      });
+      await fsp2.rename(tmp, safe);
+    } catch (err) {
+      try {
+        await fsp2.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 (!path3.isAbsolute(p)) {
+      throw new FsError("INVALID_PATH", p, "path must be absolute (ACP requirement)");
+    }
+    const resolved = path3.resolve(p);
+    const rootWithSep = this.root.endsWith(path3.sep) ? this.root : this.root + path3.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
+function pickAllow(options) {
+  const ranked = [...options].sort((a, b) => {
+    const score = (k) => {
+      if (k === "allow_once") return 0;
+      if (k === "allow_always") 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 };
+}
+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;
+  commandTimeoutMs;
+  outputByteLimit;
+  nextId = 1;
+  constructor(opts) {
+    this.projectRoot = path3.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 = path3.resolve(cwd);
+    const rootWithSep = this.projectRoot.endsWith(path3.sep) ? this.projectRoot : this.projectRoot + path3.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;
+  // 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;
+    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;
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // 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.
+   */
+  static async start(opts) {
+    const transportOpts = {
+      command: opts.command,
+      args: opts.args ? [...opts.args] : [],
+      handshakeTimeoutMs: 3e4,
+      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", `${spawnErrLabel}: ${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;
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // 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
+      },
+      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 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
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Authenticate with the agent using one of the advertised auth methods.
+   * Call this AFTER start() and BEFORE any session/new call.
+   *
+   * 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(blocks, signal, onProgress) {
+    if (this.closed) {
+      throw new ACPSessionError("closed", "session is closed");
+    }
+    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 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: blocks
+      },
+      this.timeoutMs
+    );
+    let cancelled = false;
+    const onAbort = () => {
+      cancelled = true;
+      this.transport.send({
+        jsonrpc: "2.0",
+        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.progressHandler = null;
+    }
+    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,
+      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: servers
+    });
+    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;
+  }
+  /**
+   * 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"));
+    }
+    this.pending.clear();
+    try {
+      this.transport.stop();
+    } 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
+  // ────────────────────────────────────────────────────────────────────
+  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));
+      });
+    });
+  }
+  /**
+   * 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);
+      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?.startsWith("terminal/")) {
+      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}`);
+    }
+  }
+  handleUpdate(msg) {
+    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.scratch.text += text;
+          this.emitProgress({ type: "message", text });
+        }
+        return;
+      }
+      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": {
+        this.captureToolCall(u, u.sessionUpdate === "tool_call");
+        return;
+      }
+      case "plan":
+        if (Array.isArray(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") {
+          const usage = {
+            used: u.used,
+            size: u.size,
+            ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
+          };
+          this.scratch.usage = usage;
+          this.emitProgress({ type: "usage", usage });
+        }
+        return;
+      case "available_commands_update":
+      case "current_mode_update":
+      case "config_option_update":
+      case "session_info_update":
+      case "user_message_chunk":
+      case "next_edit_suggestions":
+      case "elicitation":
+        return;
+      default:
+        return;
+    }
+  }
+  /**
+   * 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
+    });
+  }
+  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: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
+  }
+  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.sendErrorResponse(id, -32602, "toolCall is required");
+      return;
+    }
+    const policyAbort = new AbortController();
+    const outcome = await this.permissionPolicy({
+      toolCall,
+      options,
+      signal: policyAbort.signal
+    });
+    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.sendErrorResponse(id, -32602, "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.sendResult(id, result);
+      } else {
+        await this.fileServer.writeTextFile({
+          sessionId: params.sessionId ?? "",
+          path: params.path,
+          content: params.content ?? ""
+        });
+        await this.sendResult(id, {});
+      }
+    } catch (err) {
+      const code = err instanceof FsError ? -32602 : -32603;
+      const message = err instanceof Error ? err.message : String(err);
+      await this.sendErrorResponse(id, 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.sendResult(id, result);
+          return;
+        }
+        case "terminal/output": {
+          const terminalId = String(params.terminalId ?? "");
+          const out = this.terminalServer.output(terminalId);
+          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.sendResult(id, exit);
+          return;
+        }
+        case "terminal/kill": {
+          const terminalId = String(params.terminalId ?? "");
+          this.terminalServer.kill(terminalId);
+          await this.sendResult(id, {});
+          return;
+        }
+        case "terminal/release": {
+          const terminalId = String(params.terminalId ?? "");
+          this.terminalServer.release(terminalId);
+          await this.sendResult(id, {});
+          return;
+        }
+        default:
+          await this.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      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;
+  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
+    return b.resource.text;
+  }
+  return "";
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function emptyRunResult(stopReason) {
+  return {
+    text: "",
+    stopReason,
+    hasText: false,
+    toolCalls: [],
+    diffs: [],
+    thoughts: ""
+  };
+}
+
+// src/agent/protocol-handler.ts
+function toWire(msg) {
+  return msg;
+}
+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 = [
+  {
+    id: DEFAULT_MODE_ID,
+    name: "Code",
+    description: "Default agent mode for code-generation tasks."
+  }
+];
+var ACPProtocolHandler = class {
+  transport;
+  defaultCwd;
+  runTurn;
+  onSessionNew;
+  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;
+    this.runTurn = opts.runTurn;
+    this.onSessionNew = opts.onSessionNew ?? (() => {
+    });
+    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
+   * message (rare; reserved for future use by the server's own
+   * shutdown signal).
+   */
+  async handleMessage(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;
+    }
+    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;
+  }
+  /** Abort all active turns and drop session state. */
+  close() {
+    for (const [, session] of this.sessions) {
+      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
+  // ────────────────────────────────────────────────────────────────────
+  async handleRequest(id, method, params) {
+    if (method !== "initialize" && !this.initialized) {
+      await this.sendError(id, -32e3, "Not initialized");
+      return false;
+    }
+    try {
+      switch (method) {
+        case "initialize":
+          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":
+          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);
+        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;
+      }
+    } catch (err) {
+      const { code, message, data } = errorToJsonRpc(err);
+      await this.sendError(id, code, message, data);
+      return false;
+    }
+  }
+  async handleInitialize(id, params) {
+    const p = params ?? {};
+    if (p.clientCapabilities && typeof p.clientCapabilities === "object") {
+      this.clientCapabilities = p.clientCapabilities;
+    }
+    this.initialized = true;
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentCapabilities: {
+          loadSession: true,
+          promptCapabilities: {
+            // 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: {
+          name: this.agentName,
+          title: "WrongStack",
+          version: WRONGSTACK_VERSION
+        },
+        authMethods: WRONGSTACK_AUTH_METHODS,
+        modes: this.modes,
+        configOptions: this.configOptions
+      }
+    }));
+    return false;
+  }
+  async handleAuthenticate(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: { outcome: "unauthenticated" }
+    }));
+    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;
+    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.persist(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 handleSessionLoad(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 ?? {};
+    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 });
+    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 }),
+        api
+      );
+    } catch (err) {
+      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.persist(session);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: { stopReason: result.stopReason }
+    }));
+    return false;
+  }
+  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;
+  }
+  async handleSetConfigOption(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : 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, configId, 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: { configOptions: [...this.configOptions] } }));
+    return false;
+  }
+  async handleSessionList(id) {
+    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;
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // 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 "$/cancel_request": {
+        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 }));
+  }
+  /** 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;
+    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;
+  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,
+      ...opts.replayFor ? { replayFor: opts.replayFor } : {},
+      ...opts.seedFor ? { seedFor: opts.seedFor } : {},
+      ...opts.store ? { store: opts.store } : {}
+    });
+  }
+  /**
+   * 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() {
+    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();
+      if (!msg) break;
+      const terminal = await this.handler.handleMessage(msg);
+      if (terminal) break;
+    }
+    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) => {
+  return { stopReason: "end_turn" };
+};
+async function main() {
+  const server = new WrongStackACPServer();
+  await server.start();
+}
+var isEntrypoint = process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
+if (isEntrypoint) {
+  main().catch((err) => {
+    writeErr(`[wstack-acp fatal] ${err}
+`);
+    process.exit(1);
+  });
+}
+
+// src/agent/server-agent-turn.ts
+function makeACPServerAgentTurn(opts) {
+  const agents = /* @__PURE__ */ new Map();
+  const timeouts = /* @__PURE__ */ new Map();
+  const history = /* @__PURE__ */ new Map();
+  const pendingSeed = /* @__PURE__ */ new Set();
+  const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+  const turn = async (input, emit, api) => {
+    let agent = agents.get(input.sessionId);
+    if (!agent) {
+      agent = await opts.agentFor(input.sessionId, process.cwd(), api);
+      agents.set(input.sessionId, agent);
+      if (pendingSeed.has(input.sessionId)) {
+        pendingSeed.delete(input.sessionId);
+        seedAgentContext(agent, history.get(input.sessionId) ?? []);
+      }
+    }
+    const turnAbort = new AbortController();
+    const abortForTimeout = () => turnAbort.abort();
+    const onParentAbort = () => turnAbort.abort();
+    if (input.signal.aborted) {
+      turnAbort.abort();
+    } else {
+      input.signal.addEventListener("abort", onParentAbort, { once: true });
+    }
+    const timer = setTimeout(() => {
+      timeouts.delete(input.sessionId);
+      abortForTimeout();
+    }, timeoutMs);
+    timeouts.set(input.sessionId, timer);
+    const unsub = [];
+    const bus = agent.events;
+    if (bus?.on) {
+      unsub.push(
+        bus.on("tool.started", (e) => {
+          emit({
+            sessionUpdate: "tool_call",
+            toolCallId: e.id,
+            title: toolTitle(e.name, e.input),
+            kind: toolNameToKind(e.name),
+            status: "in_progress",
+            ...isRecord2(e.input) ? { rawInput: e.input } : {}
+          });
+        }),
+        bus.on("tool.executed", (e) => {
+          emit({
+            sessionUpdate: "tool_call_update",
+            toolCallId: e.id ?? e.name,
+            status: e.ok ? "completed" : "failed",
+            ...e.output !== void 0 ? {
+              content: [
+                { type: "content", content: { type: "text", text: e.output } }
+              ]
+            } : {}
+          });
+        })
+      );
+    }
+    try {
+      const userInput = promptToAgentInput(input.prompt);
+      const result = await agent.run(userInput, { signal: turnAbort.signal });
+      const text = extractText2(result);
+      if (text) {
+        emit({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        });
+      }
+      const userText = promptToText(input.prompt);
+      const hist = history.get(input.sessionId) ?? [];
+      if (userText) {
+        hist.push({ sessionUpdate: "user_message_chunk", content: { type: "text", text: userText } });
+      }
+      if (text) {
+        hist.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+      }
+      if (hist.length > 0) history.set(input.sessionId, hist);
+      const plan = extractPlan(result);
+      if (plan.length > 0) {
+        emit({
+          sessionUpdate: "plan",
+          entries: plan
+        });
+      }
+      const usage = extractUsage(result);
+      if (usage) {
+        emit({
+          sessionUpdate: "usage_update",
+          used: usage.used,
+          size: usage.size,
+          ...usage.cost ? { cost: usage.cost } : {}
+        });
+      }
+      const result_out = {
+        // `turnAbort.signal` covers both client cancellation and the
+        // wall-clock timeout, so either maps to stopReason 'cancelled'.
+        stopReason: pickStopReason(result, turnAbort.signal)
+      };
+      if (text) result_out.text = text;
+      const runTurnPlan = extractPlan(result);
+      if (runTurnPlan.length > 0) result_out.plan = runTurnPlan;
+      if (usage) result_out.usage = usage;
+      return result_out;
+    } finally {
+      clearTimeout(timer);
+      timeouts.delete(input.sessionId);
+      input.signal.removeEventListener("abort", onParentAbort);
+      for (const u of unsub) u();
+    }
+  };
+  const replay = (sessionId) => history.get(sessionId) ?? [];
+  const seed = (sessionId, incoming) => {
+    if (incoming.length === 0) return;
+    history.set(sessionId, [...incoming]);
+    pendingSeed.add(sessionId);
+  };
+  return Object.assign(turn, { replay, seed });
+}
+function seedAgentContext(agent, history) {
+  const state = agent.ctx?.state;
+  if (!state?.appendMessage) return;
+  for (const u of history) {
+    const text = u.content?.text;
+    if (typeof text !== "string" || text.length === 0) continue;
+    const role = u.sessionUpdate === "user_message_chunk" ? "user" : "assistant";
+    state.appendMessage({ role, content: text });
+  }
+}
+function toolNameToKind(name) {
+  const n = name.toLowerCase();
+  if (n.includes("read") || n.includes("cat")) return "read";
+  if (n.includes("write") || n.includes("edit") || n.includes("apply") || n.includes("patch")) return "edit";
+  if (n.includes("delete") || n.includes("rm")) return "delete";
+  if (n.includes("move") || n.includes("rename") || n.includes("mv")) return "move";
+  if (n.includes("grep") || n.includes("glob") || n.includes("search") || n.includes("find")) return "search";
+  if (n.includes("bash") || n.includes("shell") || n.includes("exec") || n.includes("run") || n.includes("terminal")) return "execute";
+  if (n.includes("fetch") || n.includes("http") || n.includes("web") || n.includes("url")) return "fetch";
+  if (n.includes("think") || n.includes("plan")) return "think";
+  return "other";
+}
+function toolTitle(name, input) {
+  if (isRecord2(input)) {
+    const path4 = input.path ?? input.file ?? input.filePath ?? input.pattern ?? input.command;
+    if (typeof path4 === "string" && path4.length > 0) {
+      return `${name}: ${path4.length > 80 ? `${path4.slice(0, 77)}\u2026` : path4}`;
+    }
+  }
+  return name;
+}
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function promptToAgentInput(blocks) {
+  const hasImage = blocks.some((b) => b.type === "image");
+  if (!hasImage) {
+    return promptToText(blocks);
+  }
+  const out = [];
+  for (const b of blocks) {
+    if (b.type === "text") {
+      out.push({ type: "text", text: b.text });
+    } else if (b.type === "image") {
+      out.push({
+        type: "image",
+        source: { type: "base64", media_type: b.mimeType, data: b.data }
+      });
+    } else if (b.type === "audio") {
+      out.push({ type: "text", text: `[audio: ${b.mimeType}]` });
+    } else if (b.type === "resource") {
+      const text = "text" in b.resource && typeof b.resource.text === "string" ? b.resource.text : `[embedded resource: ${b.resource.uri}]`;
+      out.push({ type: "text", text });
+    } else if (b.type === "resource_link") {
+      out.push({ type: "text", text: `[resource link: ${b.uri}]` });
+    }
+  }
+  return out;
+}
+function disposeACPServerAgentTurn(opts) {
+  return Promise.allSettled(
+    Array.from(opts.agents.values()).map((agent) => agent.teardown())
+  ).then(() => void 0);
+}
+function promptToText(blocks) {
+  const parts = [];
+  for (const b of blocks) {
+    if (b.type === "text") {
+      parts.push(b.text);
+    } else if (b.type === "image") {
+      parts.push(`[image: ${b.mimeType}]`);
+    } else if (b.type === "audio") {
+      parts.push(`[audio: ${b.mimeType}]`);
+    } else if (b.type === "resource") {
+      parts.push(`[embedded resource: ${b.resource.uri}]`);
+    } else if (b.type === "resource_link") {
+      parts.push(`[resource link: ${b.uri}]`);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function extractText2(result) {
+  if (typeof result !== "object" || result === null) return "";
+  const r = result;
+  if (typeof r.text === "string") return r.text;
+  if (Array.isArray(r.content)) {
+    const parts = [];
+    for (const c of r.content) {
+      if (typeof c === "object" && c !== null) {
+        const cb = c;
+        if (cb.type === "text" && typeof cb.text === "string") parts.push(cb.text);
+      }
+    }
+    return parts.join("");
+  }
+  return "";
+}
+function pickStopReason(result, signal) {
+  if (signal.aborted) return "cancelled";
+  if (typeof result !== "object" || result === null) return "end_turn";
+  const r = result;
+  if (r.error) {
+    return "end_turn";
+  }
+  if (typeof r.stopReason === "string" && r.stopReason) {
+    return r.stopReason;
+  }
+  return "end_turn";
+}
+function extractPlan(result) {
+  if (typeof result !== "object" || result === null) return [];
+  const r = result;
+  if (Array.isArray(r.plan)) {
+    return r.plan.filter(
+      (e) => typeof e === "object" && e !== null && typeof e.content === "string"
+    );
+  }
+  return [];
+}
+function extractUsage(result) {
+  if (typeof result !== "object" || result === null) return null;
+  const r = result;
+  if (typeof r.usage === "object" && r.usage !== null) {
+    const u = r.usage;
+    if (typeof u.used === "number" && typeof u.size === "number") {
+      return {
+        used: u.used,
+        size: u.size,
+        ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
+      };
+    }
+  }
+  return null;
+}
+var ACPSessionStore = class {
+  dir;
+  /**
+   * Memoized result of the first successful `init()`. Saved sessions
+   * are the hot path — calling `mkdir(..., {recursive:true})` on every
+   * turn adds an avoidable syscall to the per-prompt persistence flow.
+   * Cleared automatically if the directory disappears between calls.
+   */
+  initialized = false;
+  constructor(opts = {}) {
+    this.dir = opts.dir ?? path3.join(process.cwd(), ".acp-sessions");
+  }
+  /** Ensure the store directory exists. Memoized — only mkdirs once. */
+  async init() {
+    if (this.initialized) return;
+    await fsp2.mkdir(this.dir, { recursive: true });
+    this.initialized = true;
+  }
+  /**
+   * Persist a session state (and optionally its conversation history) to
+   * disk. Returns the session id. `history` enables cross-restart
+   * `session/load` replay.
+   */
+  async save(state, history) {
+    await this.init();
+    await fsp2.writeFile(
+      path3.join(this.dir, `${state.id}.json`),
+      JSON.stringify({
+        id: state.id,
+        cwd: state.cwd,
+        modeId: state.modeId,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+        title: state.title,
+        ...history && history.length > 0 ? { history } : {}
+      }),
+      "utf8"
+    );
+    await this.updateIndex(state.id, state.updatedAt);
+    return state.id;
+  }
+  /** Load a persisted session (metadata + history) from disk, or null. */
+  async load(sessionId) {
+    try {
+      const data = await fsp2.readFile(path3.join(this.dir, `${sessionId}.json`), "utf8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /** List all persisted sessions. */
+  async list() {
+    const indexEntries = await this.readIndex();
+    if (indexEntries !== null) {
+      return indexEntries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    const files = [];
+    try {
+      const entries = await fsp2.readdir(this.dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".json") && entry !== "index.json") {
+          files.push(entry);
+        }
+      }
+    } catch {
+      return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+      try {
+        const data = await fsp2.readFile(path3.join(this.dir, file), "utf8");
+        const parsed = JSON.parse(data);
+        if (parsed.id) {
+          sessions.push({ id: parsed.id, updatedAt: parsed.updatedAt ?? "" });
+        }
+      } catch {
+      }
+    }
+    sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    void this.writeIndex(sessions).catch(() => void 0);
+    return sessions;
+  }
+  /** Sidecar path that stores `{id, updatedAt}` for every saved session. */
+  indexPath() {
+    return path3.join(this.dir, "index.json");
+  }
+  /** Read the sidecar index. Returns `null` when missing or unreadable. */
+  async readIndex() {
+    try {
+      const data = await fsp2.readFile(this.indexPath(), "utf8");
+      const parsed = JSON.parse(data);
+      if (!Array.isArray(parsed)) return null;
+      const out = [];
+      for (const e of parsed) {
+        if (e && typeof e.id === "string" && typeof e.updatedAt === "string") {
+          out.push({
+            id: e.id,
+            updatedAt: e.updatedAt
+          });
+        }
+      }
+      return out;
+    } catch {
+      return null;
+    }
+  }
+  /** Atomically replace the sidecar index with the supplied entries. */
+  async writeIndex(entries) {
+    const target = this.indexPath();
+    const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    await fsp2.writeFile(tmp, JSON.stringify(entries), "utf8");
+    await fsp2.rename(tmp, target);
+  }
+  /** Update one entry in the index, adding it if missing. Best-effort. */
+  async updateIndex(id, updatedAt) {
+    let entries = await this.readIndex();
+    if (entries === null) {
+      await this.list();
+      return;
+    }
+    const i = entries.findIndex((e) => e.id === id);
+    if (i >= 0) entries[i] = { id, updatedAt };
+    else entries.push({ id, updatedAt });
+    try {
+      await this.writeIndex(entries);
+    } catch {
+    }
+  }
+  /** Delete a session file. */
+  async delete(sessionId) {
+    try {
+      await fsp2.unlink(path3.join(this.dir, `${sessionId}.json`));
+    } catch {
+    }
+    const entries = await this.readIndex();
+    if (entries === null) return;
+    const next = entries.filter((e) => e.id !== sessionId);
+    if (next.length !== entries.length) {
+      try {
+        await this.writeIndex(next);
+      } catch {
+      }
+    }
+  }
+  /** Get the store directory path. */
+  getDirectory() {
+    return this.dir;
+  }
+};
+
+// src/registry/agents.catalog.ts
+var AGENTS_CATALOG = [
+  // ── Anthropic ────────────────────────────────────────────────────────
+  {
+    id: "claude-code",
+    displayName: "Claude Code",
+    vendor: "anthropic",
+    probe: { command: "claude", args: ["--version"] },
+    // 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,
+      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"] },
+    // 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,
+      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"] },
+    // 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,
+      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 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,
+      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"] },
+    // Registry id `cline`: the `cline` npm package speaks ACP behind `--acp`.
+    acp: {
+      command: "npx",
+      args: ["-y", "cline", "--acp"]
+    },
+    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: ["acp"] },
+    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",
+    // Canonical repo URL — the org renamed; All-Hands-AI/OpenHands 301-redirects here.
+    docs: "https://github.com/OpenHands/OpenHands"
+  },
+  // ── Vendor CLIs (native binaries) ───────────────────────────────────
+  {
+    id: "qwen-code",
+    displayName: "Qwen Code",
+    vendor: "community",
+    probe: { command: "qwen", args: ["--version"] },
+    // Qwen Code (the @qwen-code/qwen-code package) speaks ACP behind `--acp`.
+    acp: { command: "qwen", args: ["--acp"] },
+    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"] },
+    // OpenCode speaks ACP via its `acp` subcommand (registry id `opencode`).
+    acp: { command: "opencode", args: ["acp"] },
+    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"] },
+    // Cursor's ACP entry is the `cursor-agent acp` binary (registry id `cursor`).
+    acp: { command: "cursor-agent", args: ["acp"] },
+    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);
+}
+
+// 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 {
+      }
+    }
+  }
+}
+
+export { ACPProtocolHandler, ACPSession, ACPSessionError, ACPSessionStore, ACP_AGENT_COMMANDS, FileServer, FsError, TerminalServer, WRONGSTACK_VERSION, WebSocketClientTransport, WrongStackACPServer, audioContent, defaultPermissionPolicy, disposeACPServerAgentTurn, imageContent, makeACPServerAgentTurn, makeACPSubagentRunner, makeACPSubagentRunnerWithStop, makePermissionPolicy, probeAcpAgent, readOnlyPermissionPolicy, resolveAcpAgentCommand, runOneAcpTask, textContent };
+//# sourceMappingURL=sdk.js.map
+//# sourceMappingURL=sdk.js.map