@wrongstack/acp 0.295.0 → 0.296.2

package/dist/client.js

@@ -1,5 +1,6 @@
 // src/agent/stdio-transport.ts
 import { expectDefined, writeErr } from "@wrongstack/core/utils";
+import { treeKill } from "@wrongstack/core/utils/tree-kill";
 
 // src/win32-cmd.ts
 var WIN32_CMD_META = /[&|<>"\r\n\0]/;
@@ -29,7 +30,7 @@ function quoteWin32CmdArg(arg) {
 var DEFAULT_MAX_FRAME_CHARS = 20 * 1024 * 1024;
 var DEFAULT_MAX_QUEUED_MESSAGES = 1e3;
 function positiveLimit(value, fallback) {
-  return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value) : fallback;
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
 var ClientTransport = class {
   child = null;
@@ -47,10 +48,7 @@ var ClientTransport = class {
       ...options
     };
     this.maxFrameChars = positiveLimit(options.maxFrameChars, DEFAULT_MAX_FRAME_CHARS);
-    this.maxQueuedMessages = positiveLimit(
-      options.maxQueuedMessages,
-      DEFAULT_MAX_QUEUED_MESSAGES
-    );
+    this.maxQueuedMessages = positiveLimit(options.maxQueuedMessages, DEFAULT_MAX_QUEUED_MESSAGES);
   }
   async start() {
     if (this.child) return;
@@ -69,13 +67,13 @@ var ClientTransport = class {
       const spawnCwd = isPkgLauncher ? os.homedir() : this.opts.cwd;
       try {
         const childArgs = this.opts.args ?? [];
-        const shim = process.platform === "win32" ? buildWin32CmdShimInvocation(this.opts.command, childArgs) : null;
-        this.child = spawn2(shim?.command ?? this.opts.command, shim?.args ?? childArgs, {
+        const invocation = spawnInvocation(this.opts.command, childArgs, process.platform);
+        this.child = spawn2(invocation.command, invocation.args, {
           env: { ...buildChildEnv2(), ...this.opts.env },
           cwd: spawnCwd,
           stdio: ["pipe", "pipe", "pipe"],
           windowsHide: true,
-          ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
+          ...verbatimOptions(invocation)
         });
       } catch (err) {
         clearTimeout(timeout);
@@ -119,6 +117,9 @@ var ClientTransport = class {
       };
       const waitForMarker = (chunk) => {
         this.buffer += chunk;
+        if (this.buffer.length > this.maxFrameChars) {
+          this.buffer = this.buffer.slice(-this.maxFrameChars);
+        }
         const idx = this.buffer.indexOf("[wstack-acp]\n");
         if (idx !== -1) {
           this.buffer = this.buffer.slice(idx + "[wstack-acp]\n".length);
@@ -140,7 +141,8 @@ var ClientTransport = class {
     });
   }
   read() {
-    if (this.messageQueue.length > 0) return Promise.resolve(expectDefined(this.messageQueue.shift()));
+    if (this.messageQueue.length > 0)
+      return Promise.resolve(expectDefined(this.messageQueue.shift()));
     if (this.closed) return Promise.resolve(null);
     return new Promise((resolve3) => {
       this.resolveRead = resolve3;
@@ -159,10 +161,7 @@ var ClientTransport = class {
     this.handlers.clear();
     const child = this.child;
     if (!child) return;
-    try {
-      child.kill();
-    } catch {
-    }
+    treeKill(child);
     this.child = null;
   }
   onChildData(chunk) {
@@ -226,15 +225,63 @@ var ClientTransport = class {
     }
   }
 };
+function spawnInvocation(command, args, platform) {
+  if (platform !== "win32") return { command, args };
+  return buildWin32CmdShimInvocation(command, args);
+}
+function verbatimOptions(invocation) {
+  return invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: invocation.windowsVerbatimArguments } : {};
+}
 
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
 
+// 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/file-server.ts
 import { randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
+var DEFAULT_FILE_OPERATIONS = {
+  stat: fsp.stat,
+  readFile: fsp.readFile,
+  writeFile: fsp.writeFile,
+  realpath: fsp.realpath,
+  rename: fsp.rename,
+  unlink: fsp.unlink
+};
 var DEFAULT_MAX_READ_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_WRITE_BYTES = 5 * 1024 * 1024;
 var FsError = class extends Error {
@@ -253,12 +300,14 @@ var FileServer = class {
   timeoutMs;
   maxReadBytes;
   maxWriteBytes;
+  operations;
   constructor(opts) {
     this.root = path.resolve(opts.projectRoot);
     this.realRoot = safeRealpathSync(this.root);
     this.timeoutMs = opts.timeoutMs ?? 3e4;
     this.maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
     this.maxWriteBytes = opts.maxWriteBytes ?? DEFAULT_MAX_WRITE_BYTES;
+    this.operations = opts.operations ?? DEFAULT_FILE_OPERATIONS;
   }
   /** Read a text file. Returns the content as a string. */
   async readTextFile(params) {
@@ -266,7 +315,7 @@ var FileServer = class {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     try {
-      const stat2 = await fsp.stat(safe).catch((err) => {
+      const stat2 = await this.operations.stat(safe).catch((err) => {
         throw mapFsError(err, safe);
       });
       if (stat2.size > this.maxReadBytes) {
@@ -276,7 +325,7 @@ var FileServer = class {
           `file is ${stat2.size} bytes, max read is ${this.maxReadBytes} bytes`
         );
       }
-      const content = await fsp.readFile(safe, {
+      const content = await this.operations.readFile(safe, {
         encoding: "utf8",
         signal: controller.signal
       });
@@ -306,20 +355,20 @@ var FileServer = class {
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     const tmp = `${safe}.${randomBytes(6).toString("hex")}.tmp`;
     try {
-      await fsp.writeFile(tmp, params.content, {
+      await this.operations.writeFile(tmp, params.content, {
         encoding: "utf8",
         signal: controller.signal
       });
       await this.assertRealInside(tmp);
       await this.assertRealInside(path.dirname(safe));
-      await fsp.rename(tmp, safe);
+      await this.operations.rename(tmp, safe);
     } catch (err) {
       if (err instanceof FsError) {
-        await fsp.unlink(tmp).catch(() => void 0);
+        await this.operations.unlink(tmp).catch(() => void 0);
         throw err;
       }
       try {
-        await fsp.unlink(tmp);
+        await this.operations.unlink(tmp);
       } catch {
       }
       if (controller.signal.aborted) {
@@ -363,12 +412,14 @@ var FileServer = class {
     for (; ; ) {
       let real;
       try {
-        real = await fsp.realpath(probe);
+        real = await this.operations.realpath(probe);
       } catch (err) {
         const code = err.code;
         if (code === "ENOENT") {
           const parent = path.dirname(probe);
-          if (parent === probe) return;
+          if (parent === probe) {
+            throw new FsError("ENOENT", resolvedPath, `no existing ancestor: ${resolvedPath}`);
+          }
           probe = parent;
           continue;
         }
@@ -466,7 +517,6 @@ var TerminalServer = class {
     this.outputByteLimit = opts.outputByteLimit ?? 1024 * 1024;
     this.maxOutputByteLimit = opts.maxOutputByteLimit ?? 16 * 1024 * 1024;
     this.maxTerminals = this.clampFiniteInt(opts.maxTerminals, 32);
-    if (this.maxTerminals < 1) throw new RangeError("maxTerminals must be at least 1");
     this.abortSignal = opts.signal;
     if (opts.signal) {
       opts.signal.addEventListener("abort", this.abortHandler, { once: true });
@@ -797,7 +847,6 @@ var WebSocketClientTransport = class {
       const ws = new WS(this.opts.url, this.opts.protocols);
       this.ws = ws;
       const timer = setTimeout(() => {
-        if (settled) return;
         settled = true;
         try {
           ws.close();
@@ -835,7 +884,7 @@ var WebSocketClientTransport = class {
     }
     try {
       const serialized = JSON.stringify(msg);
-      const buffered = Number.isFinite(this.ws.bufferedAmount) ? this.ws.bufferedAmount ?? 0 : 0;
+      const buffered = Number.isFinite(this.ws.bufferedAmount) ? this.ws.bufferedAmount : 0;
       if (buffered + Buffer.byteLength(serialized, "utf8") > this.maxBufferedBytes) {
         this.stop();
         return Promise.reject(new Error("WebSocket transport send buffer limit exceeded"));
@@ -892,10 +941,10 @@ var WebSocketClientTransport = class {
   }
 };
 function finitePositiveLimit(value, fallback) {
-  return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value) : fallback;
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
 
-// src/client/acp-session.ts
+// src/client/acp-session-errors.ts
 var ACPSessionError = class extends Error {
   kind;
   cause;
@@ -909,6 +958,264 @@ var ACPSessionError = class extends Error {
 function isJsonRpcError(v) {
   return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
 }
+
+// src/client/acp-session-updates.ts
+function createSessionScratch() {
+  return { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
+}
+function handleAcpSessionUpdate(msg, scratch, emitProgress) {
+  const update = msg.params?.update;
+  if (typeof update !== "object" || update === null) return;
+  const u = update;
+  emitProgress({ 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 });
+      }
+      return;
+    }
+    case "thought_chunk": {
+      const text = extractText(u.content);
+      if (text) {
+        scratch.thoughts += text;
+        emitProgress({ type: "thought", text });
+      }
+      return;
+    }
+    case "tool_call":
+    case "tool_call_update":
+      captureToolCall(u, u.sessionUpdate === "tool_call", scratch, emitProgress);
+      return;
+    case "plan":
+      if (Array.isArray(u.entries)) {
+        scratch.plan = u.entries;
+        emitProgress({ type: "plan", entries: u.entries });
+      }
+      return;
+    case "usage_update":
+      if (typeof u.used === "number" && typeof u.size === "number") {
+        const usage = {
+          used: u.used,
+          size: u.size,
+          ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
+        };
+        scratch.usage = usage;
+        emitProgress({ type: "usage", usage });
+      }
+      return;
+    case "available_commands_update":
+    case "current_mode_update":
+    case "config_option_update":
+    case "session_info_update":
+    case "user_message_chunk":
+    case "next_edit_suggestions":
+    case "elicitation":
+      return;
+    default:
+      return;
+  }
+}
+function captureToolCall(u, isNew, scratch, emitProgress) {
+  const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : "";
+  if (!toolCallId) return;
+  const prev = scratch.toolCalls.get(toolCallId);
+  const record = {
+    toolCallId,
+    title: typeof u.title === "string" ? u.title : prev?.title ?? toolCallId,
+    kind: typeof u.kind === "string" ? u.kind : prev?.kind,
+    status: typeof u.status === "string" ? u.status : prev?.status ?? (isNew ? "pending" : "in_progress"),
+    rawInput: isRecord(u.rawInput) ? u.rawInput : prev?.rawInput,
+    rawOutput: isRecord(u.rawOutput) ? u.rawOutput : prev?.rawOutput
+  };
+  scratch.toolCalls.set(toolCallId, record);
+  if (Array.isArray(u.content)) {
+    for (const c of u.content) {
+      if (c && typeof c === "object" && c.type === "diff") {
+        const diff = {
+          path: c.path,
+          oldText: c.oldText,
+          newText: c.newText
+        };
+        scratch.diffs.push(diff);
+        emitProgress({ type: "diff", diff });
+      }
+    }
+  }
+  emitProgress({
+    type: isNew ? "tool_call" : "tool_call_update",
+    toolCall: record
+  });
+}
+
+// src/client/acp-session-callbacks.ts
+async function handleAcpPermissionRequest(msg, permissionPolicy, sender) {
+  const id = msg.id;
+  if (id === void 0) return;
+  const params = msg.params;
+  const toolCall = params?.toolCall;
+  const options = Array.isArray(params?.options) ? params.options : [];
+  if (!toolCall) {
+    await sender.sendErrorResponse(id, -32602, "toolCall is required");
+    return;
+  }
+  const policyAbort = new AbortController();
+  try {
+    const outcome = await permissionPolicy({
+      toolCall,
+      options,
+      signal: policyAbort.signal
+    });
+    await sender.sendResult(id, { outcome });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
+  }
+}
+async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
+  const id = msg.id;
+  if (id === void 0) return;
+  const params = msg.params;
+  if (!params?.path) {
+    await sender.sendErrorResponse(id, -32602, "path is required");
+    return;
+  }
+  if (msg.method === "fs/write_text_file") {
+    const allowed = await authorizeAcpCallback(permissionPolicy, {
+      toolCallId: `acp-fs-write-${id}`,
+      title: `Write file: ${params.path}`,
+      kind: "edit",
+      rawInput: { path: params.path, sessionId: params.sessionId }
+    });
+    if (!allowed) {
+      await sender.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
+      return;
+    }
+  }
+  try {
+    if (msg.method === "fs/read_text_file") {
+      const result = await fileServer.readTextFile({
+        sessionId: params.sessionId ?? "",
+        path: params.path
+      });
+      await sender.sendResult(id, result);
+    } else {
+      await fileServer.writeTextFile({
+        sessionId: params.sessionId ?? "",
+        path: params.path,
+        content: params.content ?? ""
+      });
+      await sender.sendResult(id, {});
+    }
+  } catch (err) {
+    const code = err instanceof FsError ? -32602 : -32603;
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, code, message);
+  }
+}
+async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender) {
+  const id = msg.id;
+  if (id === void 0) return;
+  const params = msg.params ?? {};
+  try {
+    switch (msg.method) {
+      case "terminal/create": {
+        const allowed = await authorizeAcpCallback(permissionPolicy, {
+          toolCallId: `acp-terminal-create-${id}`,
+          title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
+          kind: "execute",
+          rawInput: {
+            command: params.command,
+            args: params.args,
+            cwd: params.cwd,
+            sessionId: params.sessionId
+          }
+        });
+        if (!allowed) {
+          await sender.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
+          return;
+        }
+        const createOpts = {
+          sessionId: String(params.sessionId ?? ""),
+          command: String(params.command ?? ""),
+          args: Array.isArray(params.args) ? params.args : []
+        };
+        if (Array.isArray(params.env)) {
+          createOpts.env = params.env;
+        }
+        if (typeof params.cwd === "string") {
+          createOpts.cwd = params.cwd;
+        }
+        if (typeof params.outputByteLimit === "number") {
+          createOpts.outputByteLimit = params.outputByteLimit;
+        }
+        const result = terminalServer.create(createOpts);
+        await sender.sendResult(id, result);
+        return;
+      }
+      case "terminal/output": {
+        const terminalId = String(params.terminalId ?? "");
+        const out = terminalServer.output(terminalId);
+        await sender.sendResult(id, out);
+        return;
+      }
+      case "terminal/wait_for_exit": {
+        const terminalId = String(params.terminalId ?? "");
+        const exit = await terminalServer.waitForExit(terminalId);
+        await sender.sendResult(id, exit);
+        return;
+      }
+      case "terminal/kill": {
+        const terminalId = String(params.terminalId ?? "");
+        terminalServer.kill(terminalId);
+        await sender.sendResult(id, {});
+        return;
+      }
+      case "terminal/release": {
+        const terminalId = String(params.terminalId ?? "");
+        terminalServer.release(terminalId);
+        await sender.sendResult(id, {});
+        return;
+      }
+      default:
+        await sender.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, -32603, message);
+  }
+}
+async function authorizeAcpCallback(permissionPolicy, partial) {
+  try {
+    const outcome = await permissionPolicy({
+      toolCall: {
+        sessionUpdate: "tool_call_update",
+        toolCallId: partial.toolCallId,
+        title: partial.title,
+        kind: partial.kind,
+        status: "pending",
+        ...partial.rawInput ? { rawInput: partial.rawInput } : {}
+      },
+      options: [
+        { optionId: "allow", name: "Allow", kind: "allow_once" },
+        { optionId: "reject", name: "Reject", kind: "reject_once" }
+      ],
+      signal: new AbortController().signal
+    });
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
+  } catch {
+    return false;
+  }
+}
+
+// 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.ts
 var ACPSession = class _ACPSession {
   transport;
   fileServer;
@@ -1602,6 +1909,12 @@ var ACPSession = class _ACPSession {
       error: { code, message }
     });
   }
+  responseSender() {
+    return {
+      sendResult: (id, result) => this.sendResult(id, result),
+      sendErrorResponse: (id, code, message) => this.sendErrorResponse(id, code, message)
+    };
+  }
   handleMessage(msg) {
     if (msg.id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
       const pending = this.pending.get(msg.id);
@@ -1616,29 +1929,32 @@ var ACPSession = class _ACPSession {
       return;
     }
     if (msg.method === "session/update") {
-      this.handleUpdate(msg);
+      handleAcpSessionUpdate(msg, this.scratch, (event) => this.emitProgress(event));
       return;
     }
     if (msg.method === "session/request_permission") {
-      void this.handlePermissionRequest(msg);
+      void handleAcpPermissionRequest(msg, this.permissionPolicy, this.responseSender());
       return;
     }
     if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
-      void this.handleFsRequest(msg);
+      void handleAcpFsRequest(
+        msg,
+        this.fileServer,
+        this.permissionPolicy,
+        this.responseSender()
+      );
       return;
     }
     if (msg.method?.startsWith("terminal/")) {
-      void this.handleTerminalRequest(msg);
-      return;
-    }
-    if (msg.method === "mcp/connect" || msg.method === "mcp/message" || msg.method === "mcp/disconnect") {
-      if (msg.id !== void 0) {
-        this.sendResult(msg.id, {}).catch(() => {
-        });
-      }
+      void handleAcpTerminalRequest(
+        msg,
+        this.terminalServer,
+        this.permissionPolicy,
+        this.responseSender()
+      );
       return;
     }
-    if (msg.method === "elicitation/create" || msg.method === "elicitation/complete") {
+    if (isBestEffortAckMethod(msg.method)) {
       if (msg.id !== void 0) {
         this.sendResult(msg.id, {}).catch(() => {
         });
@@ -1659,98 +1975,6 @@ var ACPSession = class _ACPSession {
       );
     }
   }
-  handleUpdate(msg) {
-    const update = msg.params?.update;
-    if (typeof update !== "object" || update === null) return;
-    const u = update;
-    this.emitProgress({ type: "raw", update: u });
-    switch (u.sessionUpdate) {
-      case "agent_message_chunk": {
-        const text = extractText(u.content);
-        if (text) {
-          this.scratch.text += text;
-          this.emitProgress({ type: "message", text });
-        }
-        return;
-      }
-      case "thought_chunk": {
-        const text = extractText(u.content);
-        if (text) {
-          this.scratch.thoughts += text;
-          this.emitProgress({ type: "thought", text });
-        }
-        return;
-      }
-      case "tool_call":
-      case "tool_call_update": {
-        this.captureToolCall(u, u.sessionUpdate === "tool_call");
-        return;
-      }
-      case "plan":
-        if (Array.isArray(u.entries)) {
-          this.scratch.plan = u.entries;
-          this.emitProgress({ type: "plan", entries: u.entries });
-        }
-        return;
-      case "usage_update":
-        if (typeof u.used === "number" && typeof u.size === "number") {
-          const usage = {
-            used: u.used,
-            size: u.size,
-            ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
-          };
-          this.scratch.usage = usage;
-          this.emitProgress({ type: "usage", usage });
-        }
-        return;
-      case "available_commands_update":
-      case "current_mode_update":
-      case "config_option_update":
-      case "session_info_update":
-      case "user_message_chunk":
-      case "next_edit_suggestions":
-      case "elicitation":
-        return;
-      default:
-        return;
-    }
-  }
-  /**
-   * Fold a `tool_call` / `tool_call_update` notification into the scratch
-   * tool-call map (deduped by toolCallId), extract any `diff` content into
-   * the diffs list, and emit live progress.
-   */
-  captureToolCall(u, isNew) {
-    const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : "";
-    if (!toolCallId) return;
-    const prev = this.scratch.toolCalls.get(toolCallId);
-    const record = {
-      toolCallId,
-      title: typeof u.title === "string" ? u.title : prev?.title ?? toolCallId,
-      kind: typeof u.kind === "string" ? u.kind : prev?.kind,
-      status: typeof u.status === "string" ? u.status : prev?.status ?? (isNew ? "pending" : "in_progress"),
-      rawInput: isRecord(u.rawInput) ? u.rawInput : prev?.rawInput,
-      rawOutput: isRecord(u.rawOutput) ? u.rawOutput : prev?.rawOutput
-    };
-    this.scratch.toolCalls.set(toolCallId, record);
-    if (Array.isArray(u.content)) {
-      for (const c of u.content) {
-        if (c && typeof c === "object" && c.type === "diff") {
-          const diff = {
-            path: c.path,
-            oldText: c.oldText,
-            newText: c.newText
-          };
-          this.scratch.diffs.push(diff);
-          this.emitProgress({ type: "diff", diff });
-        }
-      }
-    }
-    this.emitProgress({
-      type: isNew ? "tool_call" : "tool_call_update",
-      toolCall: record
-    });
-  }
   emitProgress(event) {
     if (!this.progressHandler) return;
     try {
@@ -1761,217 +1985,11 @@ var ACPSession = class _ACPSession {
   /** Live progress handler installed for the duration of a `prompt()` turn. */
   progressHandler = null;
   // Per-prompt scratch state
-  scratch = { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
+  scratch = createSessionScratch();
   resetScratch() {
-    this.scratch = { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
-  }
-  async handlePermissionRequest(msg) {
-    const id = msg.id;
-    if (id === void 0) return;
-    const params = msg.params;
-    const toolCall = params?.toolCall;
-    const options = Array.isArray(params?.options) ? params.options : [];
-    if (!toolCall) {
-      await this.sendErrorResponse(id, -32602, "toolCall is required");
-      return;
-    }
-    const policyAbort = new AbortController();
-    try {
-      const outcome = await this.permissionPolicy({
-        toolCall,
-        options,
-        signal: policyAbort.signal
-      });
-      await this.sendResult(id, { outcome });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
-    }
-  }
-  /**
-   * Enforce authorization at privileged callback sinks (fs/write,
-   * terminal/create). Unlike `handlePermissionRequest` which responds to
-   * agent-initiated `session/request_permission` messages, this method is
-   * called by the handler BEFORE dispatching to FileServer/TerminalServer,
-   * closing the gap where the agent simply skips the voluntary permission
-   * request and sends the privileged callback directly.
-   *
-   * Uses the session's permission policy. The default
-   * (`readOnlyPermissionPolicy`) auto-approves only side-effect-free tool
-   * calls (read/search/fetch/think) and rejects everything else — this is
-   * the safe-by-default posture. For trusted local agents (CLI `acp spawn`,
-   * Director fan-out), inject `defaultPermissionPolicy` to grant
-   * write/execute access.
-   *
-   * Returns true if the callback is authorized, false if denied.
-   */
-  async authorizeCallback(partial) {
-    try {
-      const outcome = await this.permissionPolicy({
-        toolCall: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: partial.toolCallId,
-          title: partial.title,
-          kind: partial.kind,
-          status: "pending",
-          ...partial.rawInput ? { rawInput: partial.rawInput } : {}
-        },
-        options: [
-          { optionId: "allow", name: "Allow", kind: "allow_once" },
-          { optionId: "reject", name: "Reject", kind: "reject_once" }
-        ],
-        signal: new AbortController().signal
-      });
-      return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
-    } catch {
-      return false;
-    }
-  }
-  async handleFsRequest(msg) {
-    const id = msg.id;
-    if (id === void 0) return;
-    const params = msg.params;
-    if (!params?.path) {
-      await this.sendErrorResponse(id, -32602, "path is required");
-      return;
-    }
-    if (msg.method === "fs/write_text_file") {
-      const allowed = await this.authorizeCallback({
-        toolCallId: `acp-fs-write-${id}`,
-        title: `Write file: ${params.path}`,
-        kind: "edit",
-        rawInput: { path: params.path, sessionId: params.sessionId }
-      });
-      if (!allowed) {
-        await this.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
-        return;
-      }
-    }
-    try {
-      if (msg.method === "fs/read_text_file") {
-        const result = await this.fileServer.readTextFile({
-          sessionId: params.sessionId ?? "",
-          path: params.path
-        });
-        await this.sendResult(id, result);
-      } else {
-        await this.fileServer.writeTextFile({
-          sessionId: params.sessionId ?? "",
-          path: params.path,
-          content: params.content ?? ""
-        });
-        await this.sendResult(id, {});
-      }
-    } catch (err) {
-      const code = err instanceof FsError ? -32602 : -32603;
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, code, message);
-    }
-  }
-  async handleTerminalRequest(msg) {
-    const id = msg.id;
-    if (id === void 0) return;
-    const params = msg.params ?? {};
-    try {
-      switch (msg.method) {
-        case "terminal/create": {
-          const allowed = await this.authorizeCallback({
-            toolCallId: `acp-terminal-create-${id}`,
-            title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
-            kind: "execute",
-            rawInput: {
-              command: params.command,
-              args: params.args,
-              cwd: params.cwd,
-              sessionId: params.sessionId
-            }
-          });
-          if (!allowed) {
-            await this.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
-            return;
-          }
-          const createOpts = {
-            sessionId: String(params.sessionId ?? ""),
-            command: String(params.command ?? ""),
-            args: Array.isArray(params.args) ? params.args : []
-          };
-          if (Array.isArray(params.env)) {
-            createOpts.env = params.env;
-          }
-          if (typeof params.cwd === "string") {
-            createOpts.cwd = params.cwd;
-          }
-          if (typeof params.outputByteLimit === "number") {
-            createOpts.outputByteLimit = params.outputByteLimit;
-          }
-          const result = this.terminalServer.create(createOpts);
-          await this.sendResult(id, result);
-          return;
-        }
-        case "terminal/output": {
-          const terminalId = String(params.terminalId ?? "");
-          const out = this.terminalServer.output(terminalId);
-          await this.sendResult(id, out);
-          return;
-        }
-        case "terminal/wait_for_exit": {
-          const terminalId = String(params.terminalId ?? "");
-          const exit = await this.terminalServer.waitForExit(terminalId);
-          await this.sendResult(id, exit);
-          return;
-        }
-        case "terminal/kill": {
-          const terminalId = String(params.terminalId ?? "");
-          this.terminalServer.kill(terminalId);
-          await this.sendResult(id, {});
-          return;
-        }
-        case "terminal/release": {
-          const terminalId = String(params.terminalId ?? "");
-          this.terminalServer.release(terminalId);
-          await this.sendResult(id, {});
-          return;
-        }
-        default:
-          await this.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, -32603, message);
-    }
+    this.scratch = createSessionScratch();
   }
 };
-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/integration/acp-subagent-runner.ts
 async function makeACPSubagentRunner(options) {
@@ -2100,16 +2118,8 @@ function mapACPKind(acpKind) {
   }
 }
 function isRetryable(kind) {
-  switch (kind) {
-    case "provider_5xx":
-    case "provider_rate_limit":
-    case "provider_timeout":
-    case "tool_threw":
-    case "budget_timeout":
-      return true;
-    default:
-      return false;
-  }
+  void kind;
+  return false;
 }
 
 // src/client/tool-translator.ts