@wrongstack/acp 0.309.1 → 0.310.0

package/dist/agent.js

@@ -1,289 +1,3 @@
-// src/agent/stdio-transport.ts
-import { expectDefined, writeErr } from "@wrongstack/core/utils";
-import { treeKill } from "@wrongstack/core/utils/tree-kill";
-var DEFAULT_MAX_FRAME_CHARS = 20 * 1024 * 1024;
-var DEFAULT_MAX_QUEUED_MESSAGES = 1e3;
-var DEFAULT_MAX_QUEUED_CHARS = 32 * 1024 * 1024;
-function positiveLimit(value, fallback) {
-  return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
-}
-var StdioTransport = class {
-  stdin = process.stdin;
-  stdout = process.stdout;
-  stderr = process.stderr;
-  buffer = "";
-  handlers = /* @__PURE__ */ new Set();
-  claimHandlers = /* @__PURE__ */ new Set();
-  closed = false;
-  resolveRead = null;
-  messageQueue = [];
-  queuedChars = 0;
-  maxFrameChars;
-  maxQueuedMessages;
-  maxQueuedChars;
-  onStdinData = (chunk) => this.onData(chunk);
-  onStdinEnd = () => this.handleClose();
-  onStdinError = (err) => this.failAll(err);
-  constructor(opts = {}) {
-    this.maxFrameChars = positiveLimit(opts.maxFrameChars, DEFAULT_MAX_FRAME_CHARS);
-    this.maxQueuedMessages = positiveLimit(opts.maxQueuedMessages, DEFAULT_MAX_QUEUED_MESSAGES);
-    this.maxQueuedChars = positiveLimit(opts.maxQueuedChars, DEFAULT_MAX_QUEUED_CHARS);
-    this.stdin.resume();
-    this.stdin.setEncoding("utf8");
-    this.stdin.on("data", this.onStdinData);
-    this.stdin.on("end", this.onStdinEnd);
-    this.stdin.on("error", this.onStdinError);
-  }
-  sendStartupMarker() {
-    this.stdout.write("[wstack-acp]\n", "utf8");
-  }
-  send(msg) {
-    if (this.closed) return Promise.resolve();
-    return new Promise((resolve2) => {
-      const line = JSON.stringify(msg) + "\n";
-      this.stdout.write(line, "utf8", () => resolve2());
-    });
-  }
-  sendRaw(chunk) {
-    this.stdout.write(chunk, "utf8");
-  }
-  read() {
-    if (this.messageQueue.length > 0) {
-      const queued = expectDefined(this.messageQueue.shift());
-      this.queuedChars = Math.max(0, this.queuedChars - queued.chars);
-      return Promise.resolve(queued.message);
-    }
-    if (this.closed) return Promise.resolve(null);
-    return new Promise((resolve2) => {
-      this.resolveRead = resolve2;
-    });
-  }
-  onMessage(handler) {
-    this.handlers.add(handler);
-    return () => this.handlers.delete(handler);
-  }
-  /**
-   * Register a handler that MAY claim a message by returning `true`.
-   * Claimed messages are NOT enqueued for the read() loop — they are
-   * considered fully consumed by the handler. This is how the ACP
-   * server transport prevents the correlation handler (which always
-   * fires on every message but only actually correlates responses)
-   * from starving the read() loop of pipelined requests, notifications,
-   * and any message the handler chose to ignore. See dispatch() for
-   * the gating logic.
-   */
-  onMessageClaim(handler) {
-    this.claimHandlers.add(handler);
-    return () => this.claimHandlers.delete(handler);
-  }
-  close() {
-    this.closed = true;
-    this.stdin.off("data", this.onStdinData);
-    this.stdin.off("end", this.onStdinEnd);
-    this.stdin.off("error", this.onStdinError);
-    this.stdin.pause();
-    this.resolveRead?.(null);
-    this.resolveRead = null;
-    this.buffer = "";
-    this.messageQueue.length = 0;
-    this.queuedChars = 0;
-    this.handlers.clear();
-    this.claimHandlers.clear();
-  }
-  onData(chunk) {
-    this.buffer += chunk;
-    const lines = this.buffer.split("\n");
-    this.buffer = lines.pop() ?? "";
-    if (this.buffer.length > this.maxFrameChars) {
-      this.stderr.write(
-        `[wstack-acp frame error] pending frame exceeds ${this.maxFrameChars} characters
-`,
-        "utf8"
-      );
-      this.close();
-      return;
-    }
-    for (const raw of lines) {
-      if (!raw.trim()) continue;
-      if (raw.length > this.maxFrameChars) {
-        this.stderr.write(
-          `[wstack-acp frame error] frame exceeds ${this.maxFrameChars} characters
-`,
-          "utf8"
-        );
-        this.close();
-        return;
-      }
-      try {
-        this.dispatch(JSON.parse(raw), raw.length);
-      } catch (err) {
-        this.stderr.write(`[wstack-acp parse error] ${err}
-`, "utf8");
-      }
-    }
-  }
-  dispatch(msg, chars = JSON.stringify(msg).length) {
-    if (this.resolveRead) {
-      const resolve2 = this.resolveRead;
-      this.resolveRead = null;
-      resolve2(msg);
-    } else {
-      let claimed = false;
-      for (const handler of this.claimHandlers) {
-        try {
-          if (handler(msg)) claimed = true;
-        } catch (err) {
-          this.stderr.write(`[wstack-acp handler error] ${err}
-`, "utf8");
-        }
-      }
-      if (!claimed) {
-        if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
-          this.stderr.write(
-            `[wstack-acp queue error] pending message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters
-`,
-            "utf8"
-          );
-          this.close();
-          return;
-        }
-        this.messageQueue.push({ message: msg, chars });
-        this.queuedChars += chars;
-      }
-    }
-    for (const handler of this.handlers) {
-      try {
-        handler(msg);
-      } catch (err) {
-        this.stderr.write(`[wstack-acp handler error] ${err}
-`, "utf8");
-      }
-    }
-  }
-  handleClose() {
-    this.close();
-  }
-  failAll(err) {
-    this.stderr.write(`[wstack-acp stdin error] ${err.message}
-`, "utf8");
-    this.close();
-  }
-};
-
-// src/agent/tools-registry.ts
-var ACPToolsRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  owner;
-  constructor(owner = "wrongstack") {
-    this.owner = owner;
-  }
-  /**
-   * Register one or more tools.
-   * Throws on duplicate name unless force=true.
-   */
-  register(tools) {
-    for (const tool of tools) {
-      this.tools.set(tool.name, tool);
-    }
-  }
-  /**
-   * Replace the current tool set.
-   */
-  setTools(tools) {
-    this.tools.clear();
-    for (const tool of tools) this.tools.set(tool.name, tool);
-  }
-  get(name) {
-    return this.tools.get(name);
-  }
-  has(name) {
-    return this.tools.has(name);
-  }
-  list() {
-    return Array.from(this.tools.values());
-  }
-  /** Build the ACP tools/list payload from registered tools. */
-  buildToolList() {
-    return {
-      tools: Array.from(this.tools.values()).map(
-        (t) => toACPToolDefinition(t, this.owner)
-      )
-    };
-  }
-  /**
-   * Execute a tool by name and return ACP-formatted result.
-   * Returns null if the tool is not found.
-   */
-  async execute(name, args, ctx, signal) {
-    const tool = this.tools.get(name);
-    if (!tool) return null;
-    try {
-      const result = await tool.execute(args, ctx, {
-        signal
-      });
-      return toACPToolResult(result);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: [{ type: "text", text: msg }], isError: true };
-    }
-  }
-};
-function toACPToolDefinition(tool, _owner) {
-  return {
-    name: tool.name,
-    description: tool.description,
-    inputSchema: toACPInputSchema(tool.inputSchema),
-    annotations: {
-      title: tool.name,
-      description: tool.usageHint ?? tool.description,
-      priority: toolToPriority(tool),
-      alwaysAccept: tool.permission === "auto"
-    }
-  };
-}
-function toACPInputSchema(src) {
-  if (!src || typeof src !== "object") {
-    return {};
-  }
-  const s = src;
-  const out = {};
-  if (typeof s.type === "string") out.type = s.type;
-  if (Array.isArray(s.enum)) out.enum = s.enum;
-  if (typeof s.description === "string") out.description = s.description;
-  if ("default" in s) out.default = s.default;
-  if (typeof s.minimum === "number") out.minimum = s.minimum;
-  if (typeof s.maximum === "number") out.maximum = s.maximum;
-  if (s.items) out.items = toACPInputSchema(s.items);
-  if (s.properties && typeof s.properties === "object") {
-    const props = {};
-    for (const [k, v] of Object.entries(s.properties)) {
-      props[k] = toACPInputSchema(v);
-    }
-    out.properties = props;
-    if (Array.isArray(s.required)) out.required = s.required;
-  }
-  return out;
-}
-function toACPToolResult(result) {
-  const blocks = [];
-  if (result === void 0 || result === null) {
-    return { content: [{ type: "text", text: "ok" }] };
-  }
-  if (typeof result === "string") {
-    blocks.push({ type: "text", text: result });
-  } else if (typeof result === "object") {
-    blocks.push({ type: "text", text: JSON.stringify(result, null, 2) });
-  } else {
-    blocks.push({ type: "text", text: String(result) });
-  }
-  return { content: blocks };
-}
-function toolToPriority(tool) {
-  if (tool.riskTier === "destructive") return "high";
-  if (tool.riskTier === "standard" || tool.permission === "confirm") return "medium";
-  return "low";
-}
-
 // src/agent/protocol-handler.ts
 import { randomUUID } from "node:crypto";
 
@@ -797,256 +511,564 @@ var ACPProtocolHandler = class {
     if (typeof m.method === "string") {
       return this.handleNotification(m.method, m.params);
     }
-    return false;
+    return false;
+  }
+  /** Abort all active turns and drop session state. */
+  close() {
+    for (const [sessionId, session] of this.sessions) {
+      session.abort.abort();
+      this.disposeSession(sessionId);
+    }
+    this.sessions.clear();
+    for (const [, p] of this.pendingOut) {
+      clearTimeout(p.timer);
+      p.reject(new Error("protocol handler closed"));
+    }
+    this.pendingOut.clear();
+  }
+  disposeSession(sessionId) {
+    try {
+      this.disposeFor?.(sessionId);
+    } catch {
+    }
+  }
+  sessionContext() {
+    return {
+      sessions: this.sessions,
+      maxSessions: this.maxSessions,
+      defaultCwd: this.defaultCwd,
+      modes: this.modes,
+      configOptions: this.configOptions,
+      store: this.store,
+      replayFor: this.replayFor,
+      seedFor: this.seedFor,
+      onSessionNew: this.onSessionNew,
+      allocId: () => this.allocId(),
+      persist: (state, history) => this.persist(state, history),
+      sendNotification: (params) => this.sendNotification(params),
+      sendError: (id, code, message, data) => this.sendError(id, code, message, data),
+      sendResult: (id, result) => this.sendResult(id, result),
+      request: (method, params, timeoutMs) => this.request(method, params, timeoutMs),
+      runTurn: this.runTurn,
+      clientCapabilities: this.clientCapabilities
+    };
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // 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 handleSessionNewOp(this.sessionContext(), id, params);
+        case "session/load":
+          return await handleSessionLoadOp(this.sessionContext(), 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 handleSessionPromptOp(this.sessionContext(), id, params);
+        case "session/set_mode":
+          return await handleSetModeOp(this.sessionContext(), id, params);
+        case "session/set_config_option":
+          return await handleSetConfigOptionOp(this.sessionContext(), id, params);
+        case "session/list":
+          return await this.handleSessionList(id);
+        case "session/fork":
+          return await handleSessionForkOp(this.sessionContext(), 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.sendResult(
+      id,
+      buildInitializeResult(this.agentName, this.modes, this.configOptions)
+    );
+    return false;
+  }
+  async handleAuthenticate(id, _params) {
+    await this.sendResult(id, { outcome: "unauthenticated" });
+    return false;
+  }
+  async handleLogout(id, _params) {
+    await this.sendResult(id, {});
+    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.sendResult(id, {
+        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();
+    this.sessions.delete(sessionId);
+    this.disposeSession(sessionId);
+    await this.sendResult(id, {});
+    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.sendResult(id, { configOptions: [...this.configOptions] });
+      return false;
+    }
+    const session = this.sessions.get(sessionId);
+    session.abort.abort();
+    this.sessions.delete(sessionId);
+    this.disposeSession(sessionId);
+    await this.sendResult(id, {});
+    return false;
+  }
+  async handleProvidersList(id, _params) {
+    await this.sendResult(id, {
+      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.sendResult(id, {});
+    return false;
+  }
+  async handleMcpMessage(id, _params) {
+    await this.sendError(id, -32e3, "MCP message routing not available through ACP");
+    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.sendResult(id, { 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;
+    }
   }
-  /** Abort all active turns and drop session state. */
-  close() {
-    for (const [sessionId, session] of this.sessions) {
-      session.abort.abort();
-      this.disposeSession(sessionId);
-    }
-    this.sessions.clear();
-    for (const [, p] of this.pendingOut) {
-      clearTimeout(p.timer);
-      p.reject(new Error("protocol handler closed"));
-    }
-    this.pendingOut.clear();
+  // ────────────────────────────────────────────────────────────────────
+  // Wire helpers
+  // ────────────────────────────────────────────────────────────────────
+  async sendNotification(params) {
+    await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
   }
-  disposeSession(sessionId) {
+  async sendResult(id, result) {
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result }));
+  }
+  async persist(state, history = void 0) {
+    if (!this.store) return;
     try {
-      this.disposeFor?.(sessionId);
+      await this.store.save(state, history ?? this.replayFor?.(state.id));
     } catch {
     }
   }
-  sessionContext() {
-    return {
-      sessions: this.sessions,
-      maxSessions: this.maxSessions,
-      defaultCwd: this.defaultCwd,
-      modes: this.modes,
-      configOptions: this.configOptions,
-      store: this.store,
-      replayFor: this.replayFor,
-      seedFor: this.seedFor,
-      onSessionNew: this.onSessionNew,
-      allocId: () => this.allocId(),
-      persist: (state, history) => this.persist(state, history),
-      sendNotification: (params) => this.sendNotification(params),
-      sendError: (id, code, message, data) => this.sendError(id, code, message, data),
-      sendResult: (id, result) => this.sendResult(id, result),
-      request: (method, params, timeoutMs) => this.request(method, params, timeoutMs),
-      runTurn: this.runTurn,
-      clientCapabilities: this.clientCapabilities
-    };
+  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 }));
   }
-  // ────────────────────────────────────────────────────────────────────
-  // Requests
-  // ────────────────────────────────────────────────────────────────────
-  async handleRequest(id, method, params) {
-    if (method !== "initialize" && !this.initialized) {
-      await this.sendError(id, -32e3, "Not initialized");
-      return false;
+  allocId() {
+    return `${this.nextId++}_${randomUUID().replaceAll("-", "")}`;
+  }
+};
+
+// 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 historyBytes = /* @__PURE__ */ new Map();
+  const pendingSeed = /* @__PURE__ */ new Set();
+  const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+  const maxHistoryEntries = finitePositiveLimit(opts.maxHistoryEntries, 1e3);
+  const maxHistoryBytes = finitePositiveLimit(opts.maxHistoryBytes, 8 * 1024 * 1024);
+  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",
+            ...isRecord(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 {
-      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 handleSessionNewOp(this.sessionContext(), id, params);
-        case "session/load":
-          return await handleSessionLoadOp(this.sessionContext(), 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 handleSessionPromptOp(this.sessionContext(), id, params);
-        case "session/set_mode":
-          return await handleSetModeOp(this.sessionContext(), id, params);
-        case "session/set_config_option":
-          return await handleSetConfigOptionOp(this.sessionContext(), id, params);
-        case "session/list":
-          return await this.handleSessionList(id);
-        case "session/fork":
-          return await handleSessionForkOp(this.sessionContext(), 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;
+      const userInput = promptToAgentInput(input.prompt);
+      const result = await agent.run(userInput, { signal: turnAbort.signal });
+      const text = extractText(result);
+      if (text) {
+        emit({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        });
       }
-    } 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;
+      const userText = promptToText(input.prompt);
+      const hist = history.get(input.sessionId) ?? [];
+      let retainedHistoryBytes = historyBytes.get(input.sessionId) ?? 0;
+      if (userText) {
+        const update = {
+          sessionUpdate: "user_message_chunk",
+          content: { type: "text", text: userText }
+        };
+        hist.push(update);
+        retainedHistoryBytes += replayEntryBytes(update);
+      }
+      if (text) {
+        const update = {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        };
+        hist.push(update);
+        retainedHistoryBytes += replayEntryBytes(update);
+      }
+      retainedHistoryBytes = trimHistory(
+        hist,
+        retainedHistoryBytes,
+        maxHistoryEntries,
+        maxHistoryBytes
+      );
+      if (hist.length > 0) {
+        history.set(input.sessionId, hist);
+        historyBytes.set(input.sessionId, retainedHistoryBytes);
+      } else {
+        history.delete(input.sessionId);
+        historyBytes.delete(input.sessionId);
+      }
+      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();
     }
-    this.initialized = true;
-    await this.sendResult(
-      id,
-      buildInitializeResult(this.agentName, this.modes, this.configOptions)
+  };
+  const replay = (sessionId) => [...history.get(sessionId) ?? []];
+  const seed = (sessionId, incoming) => {
+    if (incoming.length === 0) return;
+    const seeded = [...incoming];
+    const retainedBytes = trimHistory(
+      seeded,
+      seeded.reduce((total, entry) => total + replayEntryBytes(entry), 0),
+      maxHistoryEntries,
+      maxHistoryBytes
     );
-    return false;
-  }
-  async handleAuthenticate(id, _params) {
-    await this.sendResult(id, { outcome: "unauthenticated" });
-    return false;
+    history.set(sessionId, seeded);
+    historyBytes.set(sessionId, retainedBytes);
+    pendingSeed.add(sessionId);
+  };
+  const dispose = (sessionId) => {
+    const timer = timeouts.get(sessionId);
+    if (timer) clearTimeout(timer);
+    timeouts.delete(sessionId);
+    agents.delete(sessionId);
+    history.delete(sessionId);
+    historyBytes.delete(sessionId);
+    pendingSeed.delete(sessionId);
+  };
+  return Object.assign(turn, { replay, seed, dispose });
+}
+function finitePositiveLimit(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function trimHistory(entries, retainedBytes, maxEntries, maxBytes) {
+  while (entries.length > maxEntries || retainedBytes > maxBytes) {
+    const removed = entries.shift();
+    if (!removed) break;
+    retainedBytes -= replayEntryBytes(removed);
   }
-  async handleLogout(id, _params) {
-    await this.sendResult(id, {});
-    return false;
+  return Math.max(0, retainedBytes);
+}
+function replayEntryBytes(entry) {
+  return Buffer.byteLength(JSON.stringify(entry), "utf8");
+}
+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 });
   }
-  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.sendResult(id, {
-        initialMode: {
-          currentModeId: existing.modeId,
-          availableModes: this.modes
-        }
-      });
-      return false;
+}
+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 === "rm" || n.startsWith("rm_") || n.endsWith("_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 (isRecord(input)) {
+    const path3 = input.path ?? input.file ?? input.filePath ?? input.pattern ?? input.command;
+    if (typeof path3 === "string" && path3.length > 0) {
+      return `${name}: ${path3.length > 80 ? `${path3.slice(0, 77)}\u2026` : path3}`;
     }
-    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();
-    this.sessions.delete(sessionId);
-    this.disposeSession(sessionId);
-    await this.sendResult(id, {});
-    return false;
+  return name;
+}
+function isRecord(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);
   }
-  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.sendResult(id, { configOptions: [...this.configOptions] });
-      return false;
+  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}]` });
     }
-    const session = this.sessions.get(sessionId);
-    session.abort.abort();
-    this.sessions.delete(sessionId);
-    this.disposeSession(sessionId);
-    await this.sendResult(id, {});
-    return false;
-  }
-  async handleProvidersList(id, _params) {
-    await this.sendResult(id, {
-      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.sendResult(id, {});
-    return false;
-  }
-  async handleMcpMessage(id, _params) {
-    await this.sendError(id, -32e3, "MCP message routing not available through ACP");
-    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.sendResult(id, { sessions });
-    return false;
+  return out;
+}
+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}]`);
+    }
   }
-  // ────────────────────────────────────────────────────────────────────
-  // 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;
+  return parts.join("\n").trim();
+}
+function extractText(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);
       }
-      case "exit":
-        this.close();
-        return true;
-      default:
-        return false;
     }
+    return parts.join("");
   }
-  // ────────────────────────────────────────────────────────────────────
-  // Wire helpers
-  // ────────────────────────────────────────────────────────────────────
-  async sendNotification(params) {
-    await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
-  }
-  async sendResult(id, result) {
-    await this.transport.send(toWire({ jsonrpc: "2.0", id, result }));
+  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";
   }
-  async persist(state, history = void 0) {
-    if (!this.store) return;
-    try {
-      await this.store.save(state, history ?? this.replayFor?.(state.id));
-    } catch {
-    }
+  if (typeof r.stopReason === "string" && r.stopReason) {
+    return r.stopReason;
   }
-  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 }));
+  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"
+    );
   }
-  allocId() {
-    return `${this.nextId++}_${randomUUID().replaceAll("-", "")}`;
+  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";
@@ -1311,52 +1333,289 @@ var ACPSessionStore = class {
   }
 };
 
-// src/agent/ws-bridge-transport.ts
-var WsBridgeTransport = class {
-  /** @param sink Called with each outbound message to write to the socket. */
-  constructor(sink) {
-    this.sink = sink;
-  }
-  sink;
+// src/agent/stdio-transport.ts
+import { expectDefined, writeErr } from "@wrongstack/core/utils";
+import { treeKill } from "@wrongstack/core/utils/tree-kill";
+var DEFAULT_MAX_FRAME_CHARS = 20 * 1024 * 1024;
+var DEFAULT_MAX_QUEUED_MESSAGES = 1e3;
+var DEFAULT_MAX_QUEUED_CHARS = 32 * 1024 * 1024;
+function positiveLimit(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+var StdioTransport = class {
+  stdin = process.stdin;
+  stdout = process.stdout;
+  stderr = process.stderr;
+  buffer = "";
   handlers = /* @__PURE__ */ new Set();
+  claimHandlers = /* @__PURE__ */ new Set();
   closed = false;
+  resolveRead = null;
+  messageQueue = [];
+  queuedChars = 0;
+  maxFrameChars;
+  maxQueuedMessages;
+  maxQueuedChars;
+  onStdinData = (chunk) => this.onData(chunk);
+  onStdinEnd = () => this.handleClose();
+  onStdinError = (err) => this.failAll(err);
+  constructor(opts = {}) {
+    this.maxFrameChars = positiveLimit(opts.maxFrameChars, DEFAULT_MAX_FRAME_CHARS);
+    this.maxQueuedMessages = positiveLimit(opts.maxQueuedMessages, DEFAULT_MAX_QUEUED_MESSAGES);
+    this.maxQueuedChars = positiveLimit(opts.maxQueuedChars, DEFAULT_MAX_QUEUED_CHARS);
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("data", this.onStdinData);
+    this.stdin.on("end", this.onStdinEnd);
+    this.stdin.on("error", this.onStdinError);
+  }
+  sendStartupMarker() {
+    this.stdout.write("[wstack-acp]\n", "utf8");
+  }
   send(msg) {
     if (this.closed) return Promise.resolve();
-    try {
-      this.sink(msg);
-    } catch {
+    return new Promise((resolve2) => {
+      const line = JSON.stringify(msg) + "\n";
+      this.stdout.write(line, "utf8", () => resolve2());
+    });
+  }
+  sendRaw(chunk) {
+    this.stdout.write(chunk, "utf8");
+  }
+  read() {
+    if (this.messageQueue.length > 0) {
+      const queued = expectDefined(this.messageQueue.shift());
+      this.queuedChars = Math.max(0, this.queuedChars - queued.chars);
+      return Promise.resolve(queued.message);
     }
-    return Promise.resolve();
+    if (this.closed) return Promise.resolve(null);
+    return new Promise((resolve2) => {
+      this.resolveRead = resolve2;
+    });
   }
-  sendRaw() {
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  /**
+   * Register a handler that MAY claim a message by returning `true`.
+   * Claimed messages are NOT enqueued for the read() loop — they are
+   * considered fully consumed by the handler. This is how the ACP
+   * server transport prevents the correlation handler (which always
+   * fires on every message but only actually correlates responses)
+   * from starving the read() loop of pipelined requests, notifications,
+   * and any message the handler chose to ignore. See dispatch() for
+   * the gating logic.
+   */
+  onMessageClaim(handler) {
+    this.claimHandlers.add(handler);
+    return () => this.claimHandlers.delete(handler);
+  }
+  close() {
+    this.closed = true;
+    this.stdin.off("data", this.onStdinData);
+    this.stdin.off("end", this.onStdinEnd);
+    this.stdin.off("error", this.onStdinError);
+    this.stdin.pause();
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+    this.buffer = "";
+    this.messageQueue.length = 0;
+    this.queuedChars = 0;
+    this.handlers.clear();
+    this.claimHandlers.clear();
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    if (this.buffer.length > this.maxFrameChars) {
+      this.stderr.write(
+        `[wstack-acp frame error] pending frame exceeds ${this.maxFrameChars} characters
+`,
+        "utf8"
+      );
+      this.close();
+      return;
+    }
+    for (const raw of lines) {
+      if (!raw.trim()) continue;
+      if (raw.length > this.maxFrameChars) {
+        this.stderr.write(
+          `[wstack-acp frame error] frame exceeds ${this.maxFrameChars} characters
+`,
+          "utf8"
+        );
+        this.close();
+        return;
+      }
+      try {
+        this.dispatch(JSON.parse(raw), raw.length);
+      } catch (err) {
+        this.stderr.write(`[wstack-acp parse error] ${err}
+`, "utf8");
+      }
+    }
+  }
+  dispatch(msg, chars = JSON.stringify(msg).length) {
+    if (this.resolveRead) {
+      const resolve2 = this.resolveRead;
+      this.resolveRead = null;
+      resolve2(msg);
+    } else {
+      let claimed = false;
+      for (const handler of this.claimHandlers) {
+        try {
+          if (handler(msg)) claimed = true;
+        } catch (err) {
+          this.stderr.write(`[wstack-acp handler error] ${err}
+`, "utf8");
+        }
+      }
+      if (!claimed) {
+        if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
+          this.stderr.write(
+            `[wstack-acp queue error] pending message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters
+`,
+            "utf8"
+          );
+          this.close();
+          return;
+        }
+        this.messageQueue.push({ message: msg, chars });
+        this.queuedChars += chars;
+      }
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(msg);
+      } catch (err) {
+        this.stderr.write(`[wstack-acp handler error] ${err}
+`, "utf8");
+      }
+    }
+  }
+  handleClose() {
+    this.close();
+  }
+  failAll(err) {
+    this.stderr.write(`[wstack-acp stdin error] ${err.message}
+`, "utf8");
+    this.close();
+  }
+};
+
+// src/agent/tools-registry.ts
+var ACPToolsRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  owner;
+  constructor(owner = "wrongstack") {
+    this.owner = owner;
+  }
+  /**
+   * Register one or more tools.
+   * Throws on duplicate name unless force=true.
+   */
+  register(tools) {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+  /**
+   * Replace the current tool set.
+   */
+  setTools(tools) {
+    this.tools.clear();
+    for (const tool of tools) this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  /** Build the ACP tools/list payload from registered tools. */
+  buildToolList() {
+    return {
+      tools: Array.from(this.tools.values()).map((t) => toACPToolDefinition(t, this.owner))
+    };
+  }
+  /**
+   * Execute a tool by name and return ACP-formatted result.
+   * Returns null if the tool is not found.
+   */
+  async execute(name, args, ctx, signal) {
+    const tool = this.tools.get(name);
+    if (!tool) return null;
+    try {
+      const result = await tool.execute(args, ctx, {
+        signal
+      });
+      return toACPToolResult(result);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: msg }], isError: true };
+    }
   }
-  read() {
-    return Promise.resolve(null);
+};
+function toACPToolDefinition(tool, _owner) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: toACPInputSchema(tool.inputSchema),
+    annotations: {
+      title: tool.name,
+      description: tool.usageHint ?? tool.description,
+      priority: toolToPriority(tool),
+      alwaysAccept: tool.permission === "auto"
+    }
+  };
+}
+function toACPInputSchema(src) {
+  if (!src || typeof src !== "object") {
+    return {};
   }
-  onMessage(handler) {
-    this.handlers.add(handler);
-    return () => this.handlers.delete(handler);
+  const s = src;
+  const out = {};
+  if (typeof s.type === "string") out.type = s.type;
+  if (Array.isArray(s.enum)) out.enum = s.enum;
+  if (typeof s.description === "string") out.description = s.description;
+  if ("default" in s) out.default = s.default;
+  if (typeof s.minimum === "number") out.minimum = s.minimum;
+  if (typeof s.maximum === "number") out.maximum = s.maximum;
+  if (s.items) out.items = toACPInputSchema(s.items);
+  if (s.properties && typeof s.properties === "object") {
+    const props = {};
+    for (const [k, v] of Object.entries(s.properties)) {
+      props[k] = toACPInputSchema(v);
+    }
+    out.properties = props;
+    if (Array.isArray(s.required)) out.required = s.required;
   }
-  close() {
-    this.closed = true;
-    this.handlers.clear();
+  return out;
+}
+function toACPToolResult(result) {
+  const blocks = [];
+  if (result === void 0 || result === null) {
+    return { content: [{ type: "text", text: "ok" }] };
   }
-  /**
-   * Feed one inbound message from the socket. Fires the registered
-   * `onMessage` handlers (which route JSON-RPC responses to pending
-   * outbound requests inside the handler). Inbound *requests* are processed
-   * by the caller via `handler.handleMessage(msg)` — call both per message.
-   */
-  receive(msg) {
-    if (this.closed) return;
-    for (const handler of [...this.handlers]) {
-      try {
-        handler(msg);
-      } catch {
-      }
-    }
+  if (typeof result === "string") {
+    blocks.push({ type: "text", text: result });
+  } else if (typeof result === "object") {
+    blocks.push({ type: "text", text: JSON.stringify(result, null, 2) });
+  } else {
+    blocks.push({ type: "text", text: String(result) });
   }
-};
+  return { content: blocks };
+}
+function toolToPriority(tool) {
+  if (tool.riskTier === "destructive") return "high";
+  if (tool.riskTier === "standard" || tool.permission === "confirm") return "medium";
+  return "low";
+}
 
 // src/agent/wrongstack-acp-agent.ts
 import { timingSafeEqual } from "node:crypto";
@@ -1518,378 +1777,118 @@ var WrongStackACPServer = class {
         await requestPromise;
       } catch {
         res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: { code: -32603, message: "Internal error" } }));
-      }
-    });
-    return new Promise((resolve2) => {
-      this.httpServer.listen(port, host, () => {
-        writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${port}
-`);
-        this.running = true;
-        resolve2();
-      });
-    });
-  }
-  /** Stop the server. */
-  stop() {
-    this.running = false;
-    this.handler.close();
-    this.transport.close();
-    if (this.httpServer) {
-      this.httpServer.close();
-      this.httpServer = null;
-    }
-  }
-};
-var defaultEchoRunTurn = async (_input, _emit) => {
-  return { stopReason: "end_turn" };
-};
-function timingSafeTokenEqual(supplied, expected) {
-  if (!supplied || !expected) return false;
-  const a = Buffer.from(supplied);
-  const b = Buffer.from(expected);
-  if (a.length !== b.length) return false;
-  return timingSafeEqual(a, b);
-}
-function isLoopbackPeer(req) {
-  const address = req.socket.remoteAddress?.replace(/^::ffff:/i, "");
-  return address !== void 0 && isLoopbackHost(address);
-}
-function headerValue(value) {
-  return Array.isArray(value) ? value[0] : value;
-}
-function requestPath(value) {
-  return value ?? "/";
-}
-function isLoopbackHost(host) {
-  const normalized = host.trim().toLowerCase();
-  if (normalized === "localhost") return true;
-  const literal = normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
-  const version = isIP(literal);
-  if (version === 4) return literal.startsWith("127.");
-  if (version !== 6) return false;
-  const groups = expandIPv6(literal);
-  return groups !== null && groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1;
-}
-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 historyBytes = /* @__PURE__ */ new Map();
-  const pendingSeed = /* @__PURE__ */ new Set();
-  const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
-  const maxHistoryEntries = finitePositiveLimit(opts.maxHistoryEntries, 1e3);
-  const maxHistoryBytes = finitePositiveLimit(opts.maxHistoryBytes, 8 * 1024 * 1024);
-  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",
-            ...isRecord(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 = extractText(result);
-      if (text) {
-        emit({
-          sessionUpdate: "agent_message_chunk",
-          content: { type: "text", text }
-        });
-      }
-      const userText = promptToText(input.prompt);
-      const hist = history.get(input.sessionId) ?? [];
-      let retainedHistoryBytes = historyBytes.get(input.sessionId) ?? 0;
-      if (userText) {
-        const update = {
-          sessionUpdate: "user_message_chunk",
-          content: { type: "text", text: userText }
-        };
-        hist.push(update);
-        retainedHistoryBytes += replayEntryBytes(update);
-      }
-      if (text) {
-        const update = {
-          sessionUpdate: "agent_message_chunk",
-          content: { type: "text", text }
-        };
-        hist.push(update);
-        retainedHistoryBytes += replayEntryBytes(update);
-      }
-      retainedHistoryBytes = trimHistory(
-        hist,
-        retainedHistoryBytes,
-        maxHistoryEntries,
-        maxHistoryBytes
-      );
-      if (hist.length > 0) {
-        history.set(input.sessionId, hist);
-        historyBytes.set(input.sessionId, retainedHistoryBytes);
-      } else {
-        history.delete(input.sessionId);
-        historyBytes.delete(input.sessionId);
-      }
-      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 } : {}
-        });
+        res.end(JSON.stringify({ error: { code: -32603, message: "Internal error" } }));
       }
-      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();
+    });
+    return new Promise((resolve2) => {
+      this.httpServer.listen(port, host, () => {
+        writeErr2(`[wstack-acp] HTTP server listening on http://${host}:${port}
+`);
+        this.running = true;
+        resolve2();
+      });
+    });
+  }
+  /** Stop the server. */
+  stop() {
+    this.running = false;
+    this.handler.close();
+    this.transport.close();
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
     }
-  };
-  const replay = (sessionId) => [
-    ...history.get(sessionId) ?? []
-  ];
-  const seed = (sessionId, incoming) => {
-    if (incoming.length === 0) return;
-    const seeded = [...incoming];
-    const retainedBytes = trimHistory(
-      seeded,
-      seeded.reduce((total, entry) => total + replayEntryBytes(entry), 0),
-      maxHistoryEntries,
-      maxHistoryBytes
-    );
-    history.set(sessionId, seeded);
-    historyBytes.set(sessionId, retainedBytes);
-    pendingSeed.add(sessionId);
-  };
-  const dispose = (sessionId) => {
-    const timer = timeouts.get(sessionId);
-    if (timer) clearTimeout(timer);
-    timeouts.delete(sessionId);
-    agents.delete(sessionId);
-    history.delete(sessionId);
-    historyBytes.delete(sessionId);
-    pendingSeed.delete(sessionId);
-  };
-  return Object.assign(turn, { replay, seed, dispose });
-}
-function finitePositiveLimit(value, fallback) {
-  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
-}
-function trimHistory(entries, retainedBytes, maxEntries, maxBytes) {
-  while (entries.length > maxEntries || retainedBytes > maxBytes) {
-    const removed = entries.shift();
-    if (!removed) break;
-    retainedBytes -= replayEntryBytes(removed);
   }
-  return Math.max(0, retainedBytes);
+};
+var defaultEchoRunTurn = async (_input, _emit) => {
+  return { stopReason: "end_turn" };
+};
+function timingSafeTokenEqual(supplied, expected) {
+  if (!supplied || !expected) return false;
+  const a = Buffer.from(supplied);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
 }
-function replayEntryBytes(entry) {
-  return Buffer.byteLength(JSON.stringify(entry), "utf8");
+function isLoopbackPeer(req) {
+  const address = req.socket.remoteAddress?.replace(/^::ffff:/i, "");
+  return address !== void 0 && isLoopbackHost(address);
 }
-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 headerValue(value) {
+  return Array.isArray(value) ? value[0] : value;
 }
-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 === "rm" || n.startsWith("rm_") || n.endsWith("_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 requestPath(value) {
+  return value ?? "/";
 }
-function toolTitle(name, input) {
-  if (isRecord(input)) {
-    const path3 = input.path ?? input.file ?? input.filePath ?? input.pattern ?? input.command;
-    if (typeof path3 === "string" && path3.length > 0) {
-      return `${name}: ${path3.length > 80 ? `${path3.slice(0, 77)}\u2026` : path3}`;
-    }
-  }
-  return name;
+function isLoopbackHost(host) {
+  const normalized = host.trim().toLowerCase();
+  if (normalized === "localhost") return true;
+  const literal = normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
+  const version = isIP(literal);
+  if (version === 4) return literal.startsWith("127.");
+  if (version !== 6) return false;
+  const groups = expandIPv6(literal);
+  return groups !== null && groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1;
 }
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
+async function main() {
+  const server = new WrongStackACPServer();
+  await server.start();
 }
-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;
+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);
+  });
 }
-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}]`);
-    }
+
+// src/agent/ws-bridge-transport.ts
+var WsBridgeTransport = class {
+  /** @param sink Called with each outbound message to write to the socket. */
+  constructor(sink) {
+    this.sink = sink;
   }
-  return parts.join("\n").trim();
-}
-function extractText(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);
-      }
+  sink;
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  send(msg) {
+    if (this.closed) return Promise.resolve();
+    try {
+      this.sink(msg);
+    } catch {
     }
-    return parts.join("");
+    return Promise.resolve();
   }
-  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";
+  sendRaw() {
   }
-  if (typeof r.stopReason === "string" && r.stopReason) {
-    return r.stopReason;
+  read() {
+    return Promise.resolve(null);
   }
-  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"
-    );
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
   }
-  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 } : {}
-      };
+  close() {
+    this.closed = true;
+    this.handlers.clear();
+  }
+  /**
+   * Feed one inbound message from the socket. Fires the registered
+   * `onMessage` handlers (which route JSON-RPC responses to pending
+   * outbound requests inside the handler). Inbound *requests* are processed
+   * by the caller via `handler.handleMessage(msg)` — call both per message.
+   */
+  receive(msg) {
+    if (this.closed) return;
+    for (const handler of [...this.handlers]) {
+      try {
+        handler(msg);
+      } catch {
+      }
     }
   }
-  return null;
-}
+};
 export {
   ACPProtocolHandler,
   ACPSessionStore,