@wrongstack/acp 1.0.29 → 1.0.33

package/dist/index.js

@@ -239,6 +239,10 @@ async function handleSessionNewOp(ctx, id, params) {
   }
   const skipped = [];
   const mcpServers = parseMcpServers(p.mcpServers, (reason) => skipped.push(reason));
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
   const sessionId = `sess_${ctx.allocId()}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const state = {
@@ -289,6 +293,9 @@ async function handleSessionLoadOp(ctx, id, params, replayHistory = true) {
   if (!existing && sessionId && ctx.store) {
     const persisted = await ctx.store.load(sessionId);
     if (persisted) {
+      if (ctx.sessions.has(sessionId)) {
+        return handleSessionLoadOp(ctx, id, params, replayHistory);
+      }
       if (ctx.sessions.size >= ctx.maxSessions) {
         await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
         return false;
@@ -299,6 +306,13 @@ async function handleSessionLoadOp(ctx, id, params, replayHistory = true) {
       }
       const candidateCwd = loadCwd ?? persisted.cwd ?? ctx.defaultCwd;
       const restoredCwd = await resolveSessionCwd(candidateCwd) ?? ctx.defaultCwd;
+      if (ctx.sessions.has(sessionId)) {
+        return handleSessionLoadOp(ctx, id, params, replayHistory);
+      }
+      if (ctx.sessions.size >= ctx.maxSessions) {
+        await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+        return false;
+      }
       const restored = {
         id: sessionId,
         cwd: restoredCwd,
@@ -402,9 +416,17 @@ async function handleSessionForkOp(ctx, id, params) {
     }
     forkCwd = resolved;
   }
+  if (ctx.sessions.get(sourceId) !== source) {
+    await ctx.sendError(id, -32e3, `session not found: ${sourceId}`);
+    return false;
+  }
   const forkSkipped = [];
   const forkRequested = parseMcpServers(p.mcpServers, (reason) => forkSkipped.push(reason));
   const forkMcpServers = forkRequested.length > 0 ? forkRequested : source.mcpServers;
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const sessionId = `sess_${ctx.allocId()}`;
   const forked = {
@@ -1517,7 +1539,7 @@ function toACPInputSchema(src) {
   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 = {};
+    const props = /* @__PURE__ */ Object.create(null);
     for (const [k, v] of Object.entries(s.properties)) {
       props[k] = toACPInputSchema(v);
     }
@@ -1843,8 +1865,8 @@ function cancelLateAcpSession(transport, createPromise) {
         const timer = setTimeout(() => {
           reject(new Error("late session/cancel send timed out"));
         }, LATE_CANCEL_SEND_TIMEOUT_MS);
-        Promise.resolve(
-          transport.send({
+        Promise.resolve().then(
+          () => transport.send({
             jsonrpc: "2.0",
             method: "session/cancel",
             params: { sessionId: lateId }
@@ -1883,11 +1905,6 @@ function cancelLateAcpSession(transport, createPromise) {
   });
 }
 
-// src/client/acp-message-routing.ts
-function isBestEffortAckMethod(method) {
-  return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
-}
-
 // src/client/acp-session-errors.ts
 var ACPSessionError = class extends Error {
   kind;
@@ -1900,7 +1917,7 @@ var ACPSessionError = class extends Error {
   }
 };
 function isJsonRpcError(v) {
-  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
+  return typeof v === "object" && v !== null && Number.isSafeInteger(v.code) && typeof v.message === "string";
 }
 function isAuthRequiredError(err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -1948,6 +1965,7 @@ async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
   if (ctx.sessionId && ctx.sessionId !== sessionId) {
     await ctx.closeSession();
   }
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
   ctx.resetScratch();
   const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
   const id = ctx.allocId();
@@ -1959,6 +1977,7 @@ async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
   if (isJsonRpcError(result)) {
     throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
   }
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
   ctx.setSessionId(sessionId);
 }
 async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
@@ -1972,6 +1991,7 @@ async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
   if (ctx.sessionId && ctx.sessionId !== sessionId) {
     await ctx.closeSession();
   }
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
   const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
   const id = ctx.allocId();
   const result = await ctx.sendRequest(id, "session/resume", {
@@ -1982,6 +2002,7 @@ async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
   if (isJsonRpcError(result)) {
     throw new ACPSessionError("prompt_failed", `session/resume failed: ${result.message}`, result);
   }
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
   ctx.setSessionId(sessionId);
 }
 async function executeListSessions(ctx, cursor, cwd) {
@@ -2130,10 +2151,11 @@ async function executeCreateSession(ctx) {
 }
 
 // src/client/acp-session-auth.ts
+function ensureOpen(host) {
+  if (host.state === "closed") throw new ACPSessionError("closed", "session is closed");
+}
 async function authenticate(host, methodId) {
-  if (host.state === "closed") {
-    throw new ACPSessionError("closed", "session is closed");
-  }
+  ensureOpen(host);
   if (host.state !== "ready" && host.state !== "authenticated") {
     throw new ACPSessionError(
       "protocol_error",
@@ -2158,12 +2180,11 @@ async function authenticate(host, methodId) {
   if (isJsonRpcError(result)) {
     throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
   }
+  ensureOpen(host);
   host.state = "authenticated";
 }
 async function logout(host) {
-  if (host.state === "closed") {
-    throw new ACPSessionError("closed", "session is closed");
-  }
+  ensureOpen(host);
   if (!host.agentCapabilities.auth?.logout) {
     throw new ACPSessionError(
       "unsupported_capability",
@@ -2175,6 +2196,7 @@ async function logout(host) {
   if (isJsonRpcError(result)) {
     throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
   }
+  ensureOpen(host);
   host.state = "ready";
 }
 async function createSessionWithAuth(host) {
@@ -2216,6 +2238,44 @@ async function ensureAuthenticated(host) {
   );
 }
 
+// src/client/acp-session-content.ts
+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/client/acp-message-routing.ts
+function isBestEffortAckMethod(method) {
+  return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
+}
+
 // src/client/file-server.ts
 import { randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
@@ -2272,6 +2332,9 @@ var FileServer = class {
       const stat3 = await this.operations.stat(safe).catch((err) => {
         throw mapFsError(err, safe);
       });
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `readTextFile timed out after ${this.timeoutMs}ms`);
+      }
       if (stat3.size > this.maxReadBytes) {
         throw new FsError(
           "TOO_LARGE",
@@ -2283,6 +2346,17 @@ var FileServer = class {
         encoding: "utf8",
         signal: controller.signal
       });
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `readTextFile timed out after ${this.timeoutMs}ms`);
+      }
+      const actualSize = Buffer.byteLength(content, "utf8");
+      if (actualSize > this.maxReadBytes) {
+        throw new FsError(
+          "TOO_LARGE",
+          safe,
+          `file is ${actualSize} bytes after read, max read is ${this.maxReadBytes} bytes`
+        );
+      }
       if (params.line == null && params.limit == null) return { content };
       const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
       const start = (params.line ?? 1) - 1;
@@ -2321,9 +2395,21 @@ var FileServer = class {
         encoding: "utf8",
         signal: controller.signal
       });
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `writeTextFile timed out after ${this.timeoutMs}ms`);
+      }
       await this.assertRealInside(tmp);
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `writeTextFile timed out after ${this.timeoutMs}ms`);
+      }
       await this.assertRealInside(path2.dirname(safe));
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `writeTextFile timed out after ${this.timeoutMs}ms`);
+      }
       await this.operations.rename(tmp, safe);
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `writeTextFile timed out after ${this.timeoutMs}ms`);
+      }
     } catch (err) {
       if (err instanceof FsError) {
         await this.operations.unlink(tmp).catch(() => void 0);
@@ -2422,7 +2508,7 @@ function safeRealpathSync(p) {
 
 // src/client/acp-session-callbacks.ts
 var DEFAULT_PERMISSION_TIMEOUT_MS = 6e4;
-async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbackOptions = {}) {
+async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbackOptions2 = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params;
@@ -2439,7 +2525,7 @@ async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbac
         toolCall,
         options: permissionOptions
       },
-      callbackOptions
+      callbackOptions2
     );
     await sender.sendResult(id, { outcome });
   } catch (err) {
@@ -2451,7 +2537,7 @@ async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbac
     await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
   }
 }
-async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, callbackOptions = {}) {
+async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, callbackOptions2 = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params;
@@ -2468,7 +2554,7 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, cal
         kind: "edit",
         rawInput: { path: params.path, sessionId: params.sessionId }
       },
-      callbackOptions
+      callbackOptions2
     );
     if (authorization !== "allowed") {
       const isCancelled = authorization === "cancelled";
@@ -2503,7 +2589,7 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, cal
     await sender.sendErrorResponse(id, code, message);
   }
 }
-async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender, callbackOptions = {}) {
+async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender, callbackOptions2 = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params ?? {};
@@ -2523,7 +2609,7 @@ async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, s
               sessionId: params.sessionId
             }
           },
-          callbackOptions
+          callbackOptions2
         );
         if (authorization !== "allowed") {
           const isCancelled = authorization === "cancelled";
@@ -2584,7 +2670,7 @@ async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, s
     await sender.sendErrorResponse(id, -32603, message);
   }
 }
-async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions) {
+async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions2) {
   try {
     const outcome = await runPermissionWithDeadline(
       permissionPolicy,
@@ -2602,25 +2688,25 @@ async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions)
           { optionId: "reject", name: "Reject", kind: "reject_once" }
         ]
       },
-      callbackOptions
+      callbackOptions2
     );
     return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
   } catch (err) {
     return isAbortLikeError(err) ? "cancelled" : "denied";
   }
 }
-async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
-  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
+async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions2) {
+  const timeoutMs = resolvePermissionDeadline(callbackOptions2.permissionTimeoutMs);
   const controller = new AbortController();
   const abort = () => controller.abort();
   const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
   let removeAbort;
-  if (callbackOptions.signal) {
-    if (callbackOptions.signal.aborted) {
+  if (callbackOptions2.signal) {
+    if (callbackOptions2.signal.aborted) {
       abort();
     } else {
-      callbackOptions.signal.addEventListener("abort", abort, { once: true });
-      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
+      callbackOptions2.signal.addEventListener("abort", abort, { once: true });
+      removeAbort = () => callbackOptions2.signal?.removeEventListener("abort", abort);
     }
   }
   try {
@@ -2656,54 +2742,21 @@ function resolvePermissionDeadline(value) {
   return DEFAULT_PERMISSION_TIMEOUT_MS;
 }
 
-// src/client/acp-session-content.ts
-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/client/acp-session-updates.ts
 function createSessionScratch() {
   return { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
 }
-function handleAcpSessionUpdate(msg, scratch, emitProgress) {
+function handleAcpSessionUpdate(msg, scratch, emitProgress2) {
   const update = msg.params?.update;
   if (typeof update !== "object" || update === null) return;
   const u = update;
-  emitProgress({ type: "raw", update: u });
+  emitProgress2({ type: "raw", update: u });
   switch (u.sessionUpdate) {
     case "agent_message_chunk": {
       const text = extractText(u.content);
       if (text) {
         scratch.text += text;
-        emitProgress({ type: "message", text });
+        emitProgress2({ type: "message", text });
       }
       return;
     }
@@ -2712,29 +2765,29 @@ function handleAcpSessionUpdate(msg, scratch, emitProgress) {
       const text = extractText(u.content);
       if (text) {
         scratch.thoughts += text;
-        emitProgress({ type: "thought", text });
+        emitProgress2({ type: "thought", text });
       }
       return;
     }
     case "tool_call":
     case "tool_call_update":
-      captureToolCall(u, u.sessionUpdate === "tool_call", scratch, emitProgress);
+      captureToolCall(u, u.sessionUpdate === "tool_call", scratch, emitProgress2);
       return;
     case "plan":
       if (Array.isArray(u.entries)) {
         scratch.plan = u.entries;
-        emitProgress({ type: "plan", entries: u.entries });
+        emitProgress2({ type: "plan", entries: u.entries });
       }
       return;
     case "usage_update":
-      if (typeof u.used === "number" && typeof u.size === "number") {
+      if (typeof u.used === "number" && Number.isFinite(u.used) && u.used >= 0 && typeof u.size === "number" && Number.isFinite(u.size) && u.size >= 0) {
         const usage = {
           used: u.used,
           size: u.size,
           ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
         };
         scratch.usage = usage;
-        emitProgress({ type: "usage", usage });
+        emitProgress2({ type: "usage", usage });
       }
       return;
     case "available_commands_update":
@@ -2749,7 +2802,7 @@ function handleAcpSessionUpdate(msg, scratch, emitProgress) {
       return;
   }
 }
-function captureToolCall(u, isNew, scratch, emitProgress) {
+function captureToolCall(u, isNew, scratch, emitProgress2) {
   const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : "";
   if (!toolCallId) return;
   const prev = scratch.toolCalls.get(toolCallId);
@@ -2771,16 +2824,119 @@ function captureToolCall(u, isNew, scratch, emitProgress) {
           newText: c.newText
         };
         scratch.diffs.push(diff);
-        emitProgress({ type: "diff", diff });
+        emitProgress2({ type: "diff", diff });
       }
     }
   }
-  emitProgress({
+  emitProgress2({
     type: isNew ? "tool_call" : "tool_call_update",
     toolCall: record
   });
 }
 
+// src/client/acp-session-messages.ts
+function responseSender() {
+  return {
+    sendResult: (id, result) => this.sendResult(id, result),
+    sendErrorResponse: (id, code, message) => this.sendErrorResponse(id, code, message)
+  };
+}
+function callbackOptions() {
+  const promptSignal = this.promptCallbackAbort?.signal;
+  const signal = promptSignal ? AbortSignal.any([this.callbackAbort.signal, promptSignal]) : this.callbackAbort.signal;
+  return { signal, permissionTimeoutMs: Number.POSITIVE_INFINITY };
+}
+function 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) {
+      const method = pending.method;
+      const kind = method === "session/new" ? "session_create_failed" : method === "authenticate" ? "auth_failed" : "protocol_error";
+      pending.reject(
+        new ACPSessionError(kind, msg.error.message ?? "unknown JSON-RPC error", msg.error)
+      );
+    } else {
+      pending.resolve(msg.result);
+    }
+    return;
+  }
+  if (msg.method === "session/update") {
+    const updateSessionId = msg.params?.sessionId;
+    if (typeof updateSessionId === "string" && updateSessionId !== this.sessionId) return;
+    handleAcpSessionUpdate(msg, this.scratch, (event) => this.emitProgress(event));
+    return;
+  }
+  if (msg.method === "session/request_permission") {
+    handleAcpPermissionRequest(
+      msg,
+      this.permissionPolicy,
+      this.responseSender(),
+      this.callbackOptions()
+    ).catch(() => {
+    });
+    return;
+  }
+  if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
+    handleAcpFsRequest(
+      msg,
+      this.fileServer,
+      this.permissionPolicy,
+      this.responseSender(),
+      this.callbackOptions()
+    ).catch(() => {
+    });
+    return;
+  }
+  if (msg.method?.startsWith("terminal/")) {
+    handleAcpTerminalRequest(
+      msg,
+      this.terminalServer,
+      this.permissionPolicy,
+      this.responseSender(),
+      this.callbackOptions()
+    ).catch(() => {
+    });
+    return;
+  }
+  if (isBestEffortAckMethod(msg.method)) {
+    if (msg.id !== void 0) {
+      this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(() => {
+      });
+    }
+    return;
+  }
+  if (msg.method === "$/cancel_request") {
+    return;
+  }
+  if (msg.method) {
+    if (msg.id !== void 0) {
+      void this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(
+        () => {
+        }
+      );
+      return;
+    }
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "acp_session.unhandled_method",
+        method: msg.method,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+}
+function emitProgress(event) {
+  if (!this.progressHandler) return;
+  try {
+    this.progressHandler(event);
+  } catch {
+  }
+}
+
 // src/client/permission.ts
 function pickAllow(options) {
   const ranked = [...options].sort((a, b) => {
@@ -2819,6 +2975,7 @@ function makePermissionPolicy(decide) {
   return async (req) => {
     if (req.signal.aborted) return { outcome: "cancelled" };
     const allow = await decide(req);
+    if (req.signal.aborted) return { outcome: "cancelled" };
     return allow ? pickAllow(req.options) : pickReject(req.options);
   };
 }
@@ -2871,8 +3028,8 @@ var TerminalServer = class {
   constructor(opts) {
     this.projectRoot = path3.resolve(opts.projectRoot);
     this.commandTimeoutMs = opts.commandTimeoutMs ?? 5 * 6e4;
-    this.outputByteLimit = opts.outputByteLimit ?? 1024 * 1024;
-    this.maxOutputByteLimit = opts.maxOutputByteLimit ?? 16 * 1024 * 1024;
+    this.outputByteLimit = this.clampFiniteInt(opts.outputByteLimit, 1024 * 1024);
+    this.maxOutputByteLimit = this.clampFiniteInt(opts.maxOutputByteLimit, 16 * 1024 * 1024);
     this.instanceId = `term_srv_${randomBytes2(4).toString("hex")}`;
     this.maxTerminals = this.clampFiniteInt(opts.maxTerminals, 32);
     this.abortSignal = opts.signal;
@@ -2933,7 +3090,7 @@ var TerminalServer = class {
             clearTimeout(state.timeoutHandle);
             state.timeoutHandle = null;
           }
-          const exitStatus = {
+          const exitStatus = state.exitStatus ?? {
             exitCode: typeof code === "number" ? code : null,
             signal: typeof signalName === "string" ? signalName : null
           };
@@ -3133,7 +3290,7 @@ var TerminalServer = class {
    * unbounded memory growth.
    */
   clampFiniteInt(value, defaultValue) {
-    if (value === void 0 || !Number.isFinite(value) || value < 1) {
+    if (value === void 0 || !Number.isFinite(value) || value < 1 || !Number.isSafeInteger(Math.trunc(value))) {
       return defaultValue;
     }
     return Math.trunc(value);
@@ -3264,7 +3421,7 @@ var WebSocketClientTransport = class {
         )
       );
     }
-    const timeoutMs = this.opts.handshakeTimeoutMs ?? 3e4;
+    const timeoutMs = finitePositiveLimit(this.opts.handshakeTimeoutMs, 3e4);
     return new Promise((resolve5, reject) => {
       const ws = new WS(this.opts.url, this.opts.protocols);
       ws.binaryType = "arraybuffer";
@@ -3410,7 +3567,9 @@ var WebSocketClientTransport = class {
   }
 };
 function finitePositiveLimit(value, fallback) {
-  return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return Number.isSafeInteger(normalized) && normalized >= 1 ? normalized : fallback;
 }
 
 // src/client/acp-session.ts
@@ -3622,7 +3781,9 @@ var ACPSession = class _ACPSession {
   opContext() {
     const self = this;
     return {
-      closed: this.closed,
+      get closed() {
+        return self.closed;
+      },
       get sessionId() {
         return self.sessionId;
       },
@@ -3923,105 +4084,16 @@ var ACPSession = class _ACPSession {
     });
   }
   responseSender() {
-    return {
-      sendResult: (id, result) => this.sendResult(id, result),
-      sendErrorResponse: (id, code, message) => this.sendErrorResponse(id, code, message)
-    };
+    return responseSender.call(this.acpSessionMessagesHost());
   }
   callbackOptions() {
-    const promptSignal = this.promptCallbackAbort?.signal;
-    const signal = promptSignal ? AbortSignal.any([this.callbackAbort.signal, promptSignal]) : this.callbackAbort.signal;
-    return { signal, permissionTimeoutMs: Number.POSITIVE_INFINITY };
+    return callbackOptions.call(this.acpSessionMessagesHost());
   }
   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) {
-        const method = pending.method;
-        const kind = method === "session/new" ? "session_create_failed" : method === "authenticate" ? "auth_failed" : "protocol_error";
-        pending.reject(
-          new ACPSessionError(kind, msg.error.message ?? "unknown JSON-RPC error", msg.error)
-        );
-      } else {
-        pending.resolve(msg.result);
-      }
-      return;
-    }
-    if (msg.method === "session/update") {
-      const updateSessionId = msg.params?.sessionId;
-      if (typeof updateSessionId === "string" && updateSessionId !== this.sessionId) return;
-      handleAcpSessionUpdate(msg, this.scratch, (event) => this.emitProgress(event));
-      return;
-    }
-    if (msg.method === "session/request_permission") {
-      handleAcpPermissionRequest(
-        msg,
-        this.permissionPolicy,
-        this.responseSender(),
-        this.callbackOptions()
-      ).catch(() => {
-      });
-      return;
-    }
-    if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
-      handleAcpFsRequest(
-        msg,
-        this.fileServer,
-        this.permissionPolicy,
-        this.responseSender(),
-        this.callbackOptions()
-      ).catch(() => {
-      });
-      return;
-    }
-    if (msg.method?.startsWith("terminal/")) {
-      handleAcpTerminalRequest(
-        msg,
-        this.terminalServer,
-        this.permissionPolicy,
-        this.responseSender(),
-        this.callbackOptions()
-      ).catch(() => {
-      });
-      return;
-    }
-    if (isBestEffortAckMethod(msg.method)) {
-      if (msg.id !== void 0) {
-        this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(() => {
-        });
-      }
-      return;
-    }
-    if (msg.method === "$/cancel_request") {
-      return;
-    }
-    if (msg.method) {
-      if (msg.id !== void 0) {
-        void this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(
-          () => {
-          }
-        );
-        return;
-      }
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "acp_session.unhandled_method",
-          method: msg.method,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      );
-    }
+    handleMessage.call(this.acpSessionMessagesHost(), msg);
   }
   emitProgress(event) {
-    if (!this.progressHandler) return;
-    try {
-      this.progressHandler(event);
-    } catch {
-    }
+    emitProgress.call(this.acpSessionMessagesHost(), event);
   }
   progressHandler = null;
   scratch = createSessionScratch();
@@ -4051,6 +4123,23 @@ var ACPSession = class _ACPSession {
       opts: this.opts
     };
   }
+  acpSessionMessagesHost() {
+    void this.sendResult;
+    void this.sendErrorResponse;
+    void this.promptCallbackAbort;
+    void this.callbackAbort;
+    void this.pending;
+    void this.sessionId;
+    void this.scratch;
+    void this.emitProgress;
+    void this.permissionPolicy;
+    void this.responseSender;
+    void this.callbackOptions;
+    void this.fileServer;
+    void this.terminalServer;
+    void this.progressHandler;
+    return this;
+  }
 };
 
 // src/client/tool-translator.ts
@@ -4096,18 +4185,30 @@ var ToolTranslator = class {
    * response arrives.
    */
   async callTool(transport, name, args, callId = crypto.randomUUID()) {
-    await transport.send({
-      jsonrpc: "2.0",
-      method: "tools/call",
-      id: callId,
-      params: { name, arguments: args }
-    });
+    if (this.pending.has(callId)) throw new Error(`Tool call id ${callId} is already pending`);
     return new Promise((resolve5, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(callId);
         reject(new Error(`Tool call ${name} timed out after ${this.opts.totalTimeoutMs}ms`));
       }, this.opts.totalTimeoutMs);
-      this.pending.set(callId, { resolve: resolve5, reject, timeout });
+      const pending = { resolve: resolve5, reject, timeout };
+      this.pending.set(callId, pending);
+      const failSend = (err) => {
+        if (this.pending.get(callId) !== pending) return;
+        clearTimeout(timeout);
+        this.pending.delete(callId);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      try {
+        transport.send({
+          jsonrpc: "2.0",
+          method: "tools/call",
+          id: callId,
+          params: { name, arguments: args }
+        }).catch(failSend);
+      } catch (err) {
+        failSend(err);
+      }
     });
   }
   cancelAll() {
@@ -4241,7 +4342,8 @@ async function runAcpBench(opts) {
   const timeoutMs = opts.timeoutMs ?? 6e4;
   const checkFs = opts.checkFs ?? false;
   const marker = opts.marker ?? randomMarker();
-  const concurrency = Math.max(1, opts.concurrency ?? 2);
+  const requestedConcurrency = opts.concurrency ?? 2;
+  const concurrency = Number.isNaN(requestedConcurrency) ? 2 : Math.max(1, Math.floor(requestedConcurrency));
   const seen = /* @__PURE__ */ new Set();
   const ids = [];
   for (const raw of opts.agentIds) {
@@ -5081,7 +5183,8 @@ var DEFAULT_MAX_CONCURRENCY = 4;
 async function mapBound(items, worker, limit) {
   const results = new Array(items.length);
   if (items.length === 0) return results;
-  const safeLimit = Math.max(1, Math.min(limit, items.length));
+  const normalizedLimit = Number.isNaN(limit) ? DEFAULT_MAX_CONCURRENCY : Math.floor(limit);
+  const safeLimit = Math.max(1, Math.min(normalizedLimit, items.length));
   let nextIndex = 0;
   const workerCount = Math.min(safeLimit, items.length);
   const runners = [];