@wrongstack/acp 0.289.0 → 0.291.0

package/dist/sdk.js

@@ -1,3720 +1 @@
-// src/sdk.ts
-import {
-  AGENT_METHODS,
-  CLIENT_METHODS,
-  PROTOCOL_METHODS,
-  PROTOCOL_VERSION
-} from "@agentclientprotocol/sdk";
-import {
-  AgentApp,
-  ClientApp,
-  ActiveSession,
-  SessionBuilder,
-  methods
-} from "@agentclientprotocol/sdk";
-import {
-  AcpServer
-} from "@agentclientprotocol/sdk/experimental/server";
-import {
-  createWebSocketStream
-} from "@agentclientprotocol/sdk/experimental/ws-client";
-import {
-  createNodeHttpHandler,
-  createNodeWebSocketUpgradeHandler
-} from "@agentclientprotocol/sdk/experimental/node";
-
-// src/agent/stdio-transport.ts
-import { expectDefined, writeErr } from "@wrongstack/core";
-
-// src/win32-cmd.ts
-var WIN32_CMD_META = /[&|<>"\r\n\0]/;
-function buildWin32CmdShimInvocation(command, args = []) {
-  assertSafeWin32CmdArgs([command, ...args]);
-  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
-  return {
-    command: process.env["COMSPEC"] ?? "cmd.exe",
-    args: ["/d", "/c", line],
-    windowsVerbatimArguments: true
-  };
-}
-function assertSafeWin32CmdArgs(args) {
-  for (const arg of args) {
-    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
-      throw new Error(
-        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
-      );
-    }
-  }
-}
-function quoteWin32CmdArg(arg) {
-  return `"${arg}"`;
-}
-
-// src/agent/stdio-transport.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: buildChildEnv2 }, os] = await Promise.all([
-      import("node:child_process"),
-      import("@wrongstack/core"),
-      import("node: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 {
-        const childArgs = this.opts.args ?? [];
-        const shim = process.platform === "win32" ? buildWin32CmdShimInvocation(this.opts.command, childArgs) : null;
-        this.child = spawn2(shim?.command ?? this.opts.command, shim?.args ?? childArgs, {
-          env: { ...buildChildEnv2(), ...this.opts.env },
-          cwd: spawnCwd,
-          stdio: ["pipe", "pipe", "pipe"],
-          windowsHide: true,
-          ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
-        });
-      } 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;
-
-// src/client/file-server.ts
-import { randomBytes } from "node:crypto";
-import { realpathSync } from "node:fs";
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-var DEFAULT_MAX_READ_BYTES = 5 * 1024 * 1024;
-var DEFAULT_MAX_WRITE_BYTES = 5 * 1024 * 1024;
-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;
-  realRoot;
-  timeoutMs;
-  maxReadBytes;
-  maxWriteBytes;
-  constructor(opts) {
-    this.root = path.resolve(opts.projectRoot);
-    this.realRoot = safeRealpathSync(this.root);
-    this.timeoutMs = opts.timeoutMs ?? 3e4;
-    this.maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
-    this.maxWriteBytes = opts.maxWriteBytes ?? DEFAULT_MAX_WRITE_BYTES;
-  }
-  /** Read a text file. Returns the content as a string. */
-  async readTextFile(params) {
-    const safe = await this.resolveInside(params.path);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    try {
-      const stat2 = await fsp.stat(safe).catch((err) => {
-        throw mapFsError(err, safe);
-      });
-      if (stat2.size > this.maxReadBytes) {
-        throw new FsError(
-          "TOO_LARGE",
-          safe,
-          `file is ${stat2.size} bytes, max read is ${this.maxReadBytes} bytes`
-        );
-      }
-      const content = await fsp.readFile(safe, {
-        encoding: "utf8",
-        signal: controller.signal
-      });
-      return { content };
-    } catch (err) {
-      if (err instanceof FsError) throw 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 byteLength = Buffer.byteLength(params.content, "utf8");
-    if (byteLength > this.maxWriteBytes) {
-      throw new FsError(
-        "TOO_LARGE",
-        params.path,
-        `content is ${byteLength} bytes, max write is ${this.maxWriteBytes} bytes`
-      );
-    }
-    const safe = await this.resolveInside(params.path);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    const tmp = `${safe}.${randomBytes(6).toString("hex")}.tmp`;
-    try {
-      await fsp.writeFile(tmp, params.content, {
-        encoding: "utf8",
-        signal: controller.signal
-      });
-      await this.assertRealInside(tmp);
-      await this.assertRealInside(path.dirname(safe));
-      await fsp.rename(tmp, safe);
-    } catch (err) {
-      if (err instanceof FsError) {
-        await fsp.unlink(tmp).catch(() => void 0);
-        throw err;
-      }
-      try {
-        await fsp.unlink(tmp);
-      } catch {
-      }
-      if (controller.signal.aborted) {
-        throw new FsError("TIMEOUT", safe, `writeTextFile timed out after ${this.timeoutMs}ms`);
-      }
-      throw mapFsError(err, safe);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  /**
-   * Resolve a path and verify it is inside the project root by realpath.
-   * Rejects with `FsError` if the textual path, the resolved path, or the
-   * real (symlink-resolved) path escapes the project root.
-   *
-   * For files that don't exist yet (e.g. a write to a new file), the
-   * nearest existing ancestor directory is realpath-checked instead.
-   */
-  async resolveInside(p) {
-    if (typeof p !== "string" || p.length === 0) {
-      throw new FsError("INVALID_PATH", p, "path is empty or not a string");
-    }
-    if (!path.isAbsolute(p)) {
-      throw new FsError("INVALID_PATH", p, "path must be absolute (ACP requirement)");
-    }
-    const resolved = path.resolve(p);
-    const rootWithSep = this.root.endsWith(path.sep) ? this.root : this.root + path.sep;
-    if (resolved !== this.root && !resolved.startsWith(rootWithSep)) {
-      throw new FsError("OUTSIDE_ROOT", resolved, "path is outside the project root");
-    }
-    await this.assertRealInside(resolved);
-    return resolved;
-  }
-  /**
-   * Resolve `resolvedPath` through `fs.realpath` and verify the result is
-   * inside `realRoot`. For non-existent paths (new files), walk up to the
-   * nearest existing ancestor and check that instead.
-   */
-  async assertRealInside(resolvedPath) {
-    let probe = resolvedPath;
-    for (; ; ) {
-      let real;
-      try {
-        real = await fsp.realpath(probe);
-      } catch (err) {
-        const code = err.code;
-        if (code === "ENOENT") {
-          const parent = path.dirname(probe);
-          if (parent === probe) return;
-          probe = parent;
-          continue;
-        }
-        throw mapFsError(err, resolvedPath);
-      }
-      if (real === this.realRoot || real.startsWith(this.realRoot + path.sep)) return;
-      throw new FsError(
-        "OUTSIDE_ROOT",
-        resolvedPath,
-        "path resolves through a symlink outside the project root"
-      );
-    }
-  }
-};
-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 safeRealpathSync(p) {
-  try {
-    return realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-
-// 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);
-  };
-}
-
-// src/client/terminal-server.ts
-import { spawn } from "node:child_process";
-import { realpathSync as realpathSync2 } from "node:fs";
-import * as path2 from "node:path";
-import { buildChildEnv } from "@wrongstack/core/utils";
-var TerminalServer = class {
-  terminals = /* @__PURE__ */ new Map();
-  projectRoot;
-  commandTimeoutMs;
-  outputByteLimit;
-  maxOutputByteLimit;
-  nextId = 1;
-  constructor(opts) {
-    this.projectRoot = path2.resolve(opts.projectRoot);
-    this.commandTimeoutMs = opts.commandTimeoutMs ?? 5 * 6e4;
-    this.outputByteLimit = opts.outputByteLimit ?? 1024 * 1024;
-    this.maxOutputByteLimit = opts.maxOutputByteLimit ?? 16 * 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 = Math.min(
-      Math.max(1, this.clampFiniteInt(params.outputByteLimit, this.outputByteLimit)),
-      this.maxOutputByteLimit
-    );
-    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 = path2.resolve(cwd);
-    const rootWithSep = this.projectRoot.endsWith(path2.sep) ? this.projectRoot : this.projectRoot + path2.sep;
-    if (resolved !== this.projectRoot && !resolved.startsWith(rootWithSep)) {
-      return this.projectRoot;
-    }
-    try {
-      const realRoot = realpathSync2(this.projectRoot);
-      const realCwd = realpathSync2(resolved);
-      const realRootWithSep = realRoot.endsWith(path2.sep) ? realRoot : realRoot + path2.sep;
-      if (realCwd !== realRoot && !realCwd.startsWith(realRootWithSep)) {
-        return realRoot;
-      }
-      return realCwd;
-    } catch {
-      return this.projectRoot;
-    }
-  }
-  buildEnv(agentEnv) {
-    const env = buildChildEnv();
-    if (agentEnv) {
-      for (const { name, value } of agentEnv) {
-        const upper = name.toUpperCase();
-        if (DENIED_AGENT_ENV_KEYS.has(upper)) continue;
-        env[name] = value;
-      }
-    }
-    return env;
-  }
-  /**
-   * Clamp an agent-supplied numeric to a finite positive safe integer, falling
-   * back to `defaultValue` for undefined/NaN/non-finite values. Prevents
-   * negative, NaN, or Infinity values from disabling output caps or causing
-   * unbounded memory growth.
-   */
-  clampFiniteInt(value, defaultValue) {
-    if (value === void 0 || !Number.isFinite(value) || value < 1) {
-      return defaultValue;
-    }
-    return Math.trunc(value);
-  }
-};
-var DENIED_AGENT_ENV_KEYS = /* @__PURE__ */ new Set([
-  "NODE_OPTIONS",
-  "LD_PRELOAD",
-  "LD_LIBRARY_PATH",
-  "DYLD_INSERT_LIBRARIES",
-  "DYLD_LIBRARY_PATH",
-  "DYLD_FALLBACK_LIBRARY_PATH",
-  "PATH",
-  "PYTHONPATH",
-  "PYTHONSTARTUP",
-  "PERL5OPT",
-  "PERLLIB",
-  "RUBYOPT",
-  "RUBYLIB"
-]);
-
-// 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.287.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(
-        JSON.stringify({
-          level: "warn",
-          event: "acp_session.unhandled_method",
-          method: msg.method,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      );
-    }
-  }
-  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();
-    try {
-      const outcome = await this.permissionPolicy({
-        toolCall,
-        options,
-        signal: policyAbort.signal
-      });
-      await this.sendResult(id, { outcome });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
-    }
-  }
-  /**
-   * Enforce authorization at privileged callback sinks (fs/write,
-   * terminal/create). Unlike `handlePermissionRequest` which responds to
-   * agent-initiated `session/request_permission` messages, this method is
-   * called by the handler BEFORE dispatching to FileServer/TerminalServer,
-   * closing the gap where the agent simply skips the voluntary permission
-   * request and sends the privileged callback directly.
-   *
-   * Uses the session's permission policy. The default policy
-   * (`defaultPermissionPolicy`) auto-approves everything — this is correct
-   * for trusted local agents (CLI `acp spawn`, Director fan-out). For
-   * untrusted/remote agents, the host should inject
-   * `readOnlyPermissionPolicy` or an interactive policy.
-   *
-   * Returns true if the callback is authorized, false if denied.
-   */
-  async authorizeCallback(partial) {
-    try {
-      const outcome = await this.permissionPolicy({
-        toolCall: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: partial.toolCallId,
-          title: partial.title,
-          kind: partial.kind,
-          status: "pending"
-        },
-        options: [
-          { optionId: "allow", name: "Allow", kind: "allow_once" },
-          { optionId: "reject", name: "Reject", kind: "reject_once" }
-        ],
-        signal: new AbortController().signal
-      });
-      return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
-    } catch {
-      return false;
-    }
-  }
-  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;
-    }
-    if (msg.method === "fs/write_text_file") {
-      const allowed = await this.authorizeCallback({
-        toolCallId: `acp-fs-write-${id}`,
-        title: `Write file: ${params.path}`,
-        kind: "edit"
-      });
-      if (!allowed) {
-        await this.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
-        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 allowed = await this.authorizeCallback({
-            toolCallId: `acp-terminal-create-${id}`,
-            title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
-            kind: "execute"
-          });
-          if (!allowed) {
-            await this.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
-            return;
-          }
-          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: {},
-            fork: {}
-          },
-          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;
-    const 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;
-    const source = sourceId ? this.sessions.get(sourceId) : void 0;
-    if (!sourceId || !source) {
-      await this.sendError(id, -32e3, `session not found: ${sourceId}`);
-      return false;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sessionId = `sess_${this.allocId()}`;
-    const forked = {
-      id: sessionId,
-      cwd: typeof p.cwd === "string" ? p.cwd : source.cwd,
-      abort: new AbortController(),
-      modeId: source.modeId,
-      createdAt: now,
-      updatedAt: now,
-      ...source.title !== void 0 ? { title: source.title } : {}
-    };
-    const history = (this.replayFor?.(sourceId) ?? []).map((update) => ({
-      sessionUpdate: update.sessionUpdate,
-      content: structuredClone(update.content)
-    }));
-    this.sessions.set(sessionId, forked);
-    this.seedFor?.(sessionId, history);
-    this.onSessionNew(forked);
-    await this.persist(forked, history);
-    await this.sendNotification({
-      sessionId,
-      update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
-    });
-    await this.transport.send(toWire({
-      jsonrpc: "2.0",
-      id,
-      result: {
-        sessionId,
-        modes: this.modes,
-        configOptions: this.configOptions
-      }
-    }));
-    return false;
-  }
-  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, history = void 0) {
-    if (!this.store) return;
-    try {
-      await this.store.save(state, history ?? 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 };
-}
-
-// src/agent/wrongstack-acp-agent.ts
-import { fileURLToPath } from "node:url";
-import { createServer } from "node:http";
-import { writeErr as writeErr2 } from "@wrongstack/core";
-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;
-    const authToken = this.options.authToken;
-    let httpChain = Promise.resolve();
-    this.httpServer = createServer(async (req, res) => {
-      if (authToken) {
-        const url = new URL(req.url ?? "/", `http://${host}:${port}`);
-        const queryToken = url.searchParams.get("token");
-        const authHeader = req.headers["authorization"];
-        const bearerToken = Array.isArray(authHeader) ? authHeader[0]?.replace(/^Bearer\s+/i, "") : authHeader?.replace(/^Bearer\s+/i, "");
-        const supplied = queryToken ?? bearerToken ?? "";
-        if (supplied !== authToken) {
-          res.writeHead(401, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: { code: -32001, message: "Unauthorized" } }));
-          return;
-        }
-      }
-      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, Authorization");
-      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;
-      }
-      const MAX_HTTP_BODY = 10 * 1024 * 1024;
-      let body = "";
-      let bodyBytes = 0;
-      let tooLarge = false;
-      for await (const chunk of req) {
-        bodyBytes += chunk.length;
-        if (bodyBytes > MAX_HTTP_BODY) {
-          tooLarge = true;
-          break;
-        }
-        body += chunk;
-      }
-      if (tooLarge) {
-        res.writeHead(413, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: { code: -32700, message: "Request body too large" } }));
-        return;
-      }
-      let msg;
-      try {
-        msg = JSON.parse(body);
-      } catch {
-        res.writeHead(400);
-        res.end(JSON.stringify({ error: { code: -32700, message: "Parse error" } }));
-        return;
-      }
-      const isNotification = typeof msg === "object" && msg !== null && msg.id === void 0 && typeof msg.method === "string";
-      if (isNotification) {
-        try {
-          await handler.handleMessage(msg);
-        } catch {
-        }
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ notifications: [] }));
-        return;
-      }
-      const requestPromise = httpChain.then(async () => {
-        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));
-      });
-      httpChain = requestPromise.catch(() => void 0);
-      try {
-        await requestPromise;
-      } catch {
-      }
-    });
-    return new Promise((resolve3) => {
-      this.httpServer.listen(port, host, () => {
-        writeErr2(`[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) => {
-    writeErr2(`[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;
-}
-
-// src/agent/session-store.ts
-import * as fsp2 from "node:fs/promises";
-import * as path3 from "node:path";
-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) {
-    const 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"
-  },
-  // ── Moonshot AI (Kimi) ─────────────────────────────────────────────
-  {
-    id: "kimi",
-    displayName: "Kimi Code CLI",
-    vendor: "moonshot",
-    probe: { command: "kimi", args: ["--version"] },
-    // Kimi Code CLI speaks ACP behind `kimi acp`. The user must complete
-    // terminal login (`kimi` → `/login`) before launching `kimi acp`;
-    // otherwise session creation fails with `Authentication required`.
-    // The adapter reuses the CLI's existing auth state — WrongStack does
-    // NOT capture or replay the Kimi OAuth tokens.
-    // Docs: https://www.kimi.com/code/docs/en/kimi-code-cli/reference/kimi-acp.html
-    acp: { command: "kimi", args: ["acp"] },
-    supports: {
-      loadSession: true,
-      promptImages: true,
-      terminal: true,
-      fs: true
-    },
-    integration: "native",
-    docs: "https://www.kimi.com/code/docs/en/kimi-code-cli/guides/ides.html"
-  }
-];
-function findAgentDescriptor(id) {
-  return AGENTS_CATALOG.find((a) => a.id === id);
-}
-
-// src/integration/run-one-acp-task.ts
-import { SubagentBudget } from "@wrongstack/core/coordination";
-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 {
-    }
-  }
-}
-
-// 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",
-  // Kimi's live registry id is `kimi` — same as our catalog id, so the
-  // alias is identity. Listed explicitly so `resolveAcpAgentCommand`
-  // finds the live entry when the registry is synced.
-  kimi: "kimi"
-};
-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 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,
-  AGENT_METHODS,
-  AcpServer,
-  ActiveSession,
-  AgentApp,
-  CLIENT_METHODS,
-  ClientApp,
-  FileServer,
-  FsError,
-  PROTOCOL_METHODS,
-  PROTOCOL_VERSION,
-  SessionBuilder,
-  TerminalServer,
-  WRONGSTACK_VERSION,
-  WebSocketClientTransport,
-  WrongStackACPServer,
-  audioContent,
-  createNodeHttpHandler,
-  createNodeWebSocketUpgradeHandler,
-  createWebSocketStream,
-  defaultPermissionPolicy,
-  disposeACPServerAgentTurn,
-  imageContent,
-  makeACPServerAgentTurn,
-  makeACPSubagentRunner,
-  makeACPSubagentRunnerWithStop,
-  makePermissionPolicy,
-  methods,
-  probeAcpAgent,
-  readOnlyPermissionPolicy,
-  resolveAcpAgentCommand,
-  runOneAcpTask,
-  textContent
-};
 //# sourceMappingURL=sdk.js.map