@wrongstack/acp 1.0.19 → 1.0.26

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/agent/protocol-handler.ts
 import { randomUUID } from "node:crypto";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
@@ -180,7 +181,7 @@ function createRunTurnApi(sessionId, clientCapabilities, request, sendSessionUpd
     ...sendSessionUpdate ? { sendSessionUpdate } : {}
   };
 }
-function buildInitializeResult(agentName, modes, configOptions) {
+function buildInitializeResult(agentName, modes, configOptions, clientCapabilities = {}) {
   return {
     protocolVersion: ACP_PROTOCOL_VERSION,
     agentCapabilities: {
@@ -207,9 +208,6 @@ function buildInitializeResult(agentName, modes, configOptions) {
         delete: {},
         resume: {},
         fork: {}
-      },
-      auth: {
-        logout: {}
       }
     },
     agentInfo: {
@@ -217,7 +215,7 @@ function buildInitializeResult(agentName, modes, configOptions) {
       title: "WrongStack",
       version: WRONGSTACK_VERSION
     },
-    authMethods: WRONGSTACK_AUTH_METHODS,
+    authMethods: clientCapabilities.auth?.terminal === true ? WRONGSTACK_AUTH_METHODS : [],
     modes,
     configOptions
   };
@@ -247,7 +245,8 @@ async function handleSessionNewOp(ctx, id, params) {
     id: sessionId,
     cwd,
     abort: new AbortController(),
-    modeId: DEFAULT_MODE_ID,
+    modeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID,
+    configOptions: structuredClone([...ctx.configOptions]),
     createdAt: now,
     updatedAt: now,
     ...mcpServers.length > 0 ? { mcpServers } : {}
@@ -259,6 +258,7 @@ async function handleSessionNewOp(ctx, id, params) {
     sessionId,
     update: {
       sessionUpdate: "current_mode_update",
+      currentModeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID,
       modeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID
     }
   });
@@ -274,12 +274,12 @@ async function handleSessionNewOp(ctx, id, params) {
   await reportSkippedMcpServers(ctx, sessionId, skipped);
   await ctx.sendResult(id, {
     sessionId,
-    modes: ctx.modes,
-    configOptions: ctx.configOptions
+    modes: { currentModeId: state.modeId, availableModes: ctx.modes },
+    configOptions: state.configOptions
   });
   return false;
 }
-async function handleSessionLoadOp(ctx, id, params) {
+async function handleSessionLoadOp(ctx, id, params, replayHistory = true) {
   const p = params ?? {};
   const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
   const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
@@ -304,6 +304,7 @@ async function handleSessionLoadOp(ctx, id, params) {
         cwd: restoredCwd,
         abort: new AbortController(),
         modeId: persisted.modeId ?? DEFAULT_MODE_ID,
+        configOptions: structuredClone(persisted.configOptions ?? [...ctx.configOptions]),
         createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         ...persisted.title !== void 0 ? { title: persisted.title } : {},
@@ -311,51 +312,69 @@ async function handleSessionLoadOp(ctx, id, params) {
       };
       ctx.sessions.set(sessionId, restored);
       ctx.seedFor?.(sessionId, persisted.history ?? []);
-      for (const update of persisted.history ?? []) {
+      for (const update of replayHistory ? persisted.history ?? [] : []) {
         await ctx.sendNotification({ sessionId, update });
       }
-      await ctx.sendNotification({
-        sessionId,
-        update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
-      });
+      if (replayHistory)
+        await ctx.sendNotification({
+          sessionId,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentModeId: restored.modeId,
+            modeId: restored.modeId
+          }
+        });
       await reportSkippedMcpServers(ctx, sessionId, loadSkipped);
       await ctx.sendResult(id, {
-        initialMode: { currentModeId: restored.modeId, availableModes: ctx.modes }
+        modes: { currentModeId: restored.modeId, availableModes: ctx.modes },
+        configOptions: restored.configOptions
       });
       return false;
     }
   }
   if (existing) {
+    if (existing.prompting) {
+      await ctx.sendError(id, -32e3, "cannot reload a session while a prompt is running");
+      return false;
+    }
     existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (loadMcpServers.length > 0) {
+    const replay = ctx.replayFor?.(sessionId);
+    if (Array.isArray(p.mcpServers)) {
+      if (JSON.stringify(existing.mcpServers ?? []) !== JSON.stringify(loadMcpServers)) {
+        ctx.disposeFor?.(sessionId);
+        ctx.seedFor?.(sessionId, replay ?? []);
+      }
       existing.mcpServers = loadMcpServers;
     }
-    const replay = ctx.replayFor?.(sessionId);
-    if (replay) {
+    if (replayHistory && replay) {
       for (const update of replay) {
         await ctx.sendNotification({ sessionId, update });
       }
     }
-    await ctx.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "session_info_update",
-        updatedAt: existing.updatedAt
-      }
-    });
-    await ctx.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "current_mode_update",
-        modeId: existing.modeId
-      }
-    });
+    if (replayHistory)
+      await ctx.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          updatedAt: existing.updatedAt
+        }
+      });
+    if (replayHistory)
+      await ctx.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "current_mode_update",
+          currentModeId: existing.modeId,
+          modeId: existing.modeId
+        }
+      });
     await reportSkippedMcpServers(ctx, sessionId, loadSkipped);
     await ctx.sendResult(id, {
-      initialMode: {
+      modes: {
         currentModeId: existing.modeId,
         availableModes: ctx.modes
-      }
+      },
+      configOptions: existing.configOptions ?? [...ctx.configOptions]
     });
     return false;
   }
@@ -393,6 +412,7 @@ async function handleSessionForkOp(ctx, id, params) {
     cwd: forkCwd,
     abort: new AbortController(),
     modeId: source.modeId,
+    configOptions: structuredClone(source.configOptions ?? [...ctx.configOptions]),
     createdAt: now,
     updatedAt: now,
     ...source.title !== void 0 ? { title: source.title } : {},
@@ -408,13 +428,17 @@ async function handleSessionForkOp(ctx, id, params) {
   await ctx.persist(forked, history);
   await ctx.sendNotification({
     sessionId,
-    update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
+    update: {
+      sessionUpdate: "current_mode_update",
+      currentModeId: forked.modeId,
+      modeId: forked.modeId
+    }
   });
   await reportSkippedMcpServers(ctx, sessionId, forkSkipped);
   await ctx.sendResult(id, {
     sessionId,
-    modes: ctx.modes,
-    configOptions: ctx.configOptions
+    modes: { currentModeId: forked.modeId, availableModes: ctx.modes },
+    configOptions: forked.configOptions
   });
   return false;
 }
@@ -430,6 +454,11 @@ async function handleSessionPromptOp(ctx, id, params) {
     return false;
   }
   const session = ctx.sessions.get(sessionId);
+  if (session.prompting) {
+    await ctx.sendError(id, -32e3, "a prompt is already running for this session");
+    return false;
+  }
+  session.prompting = true;
   if (session.abort.signal.aborted) {
     session.abort = new AbortController();
   }
@@ -458,6 +487,8 @@ async function handleSessionPromptOp(ctx, id, params) {
       {
         sessionId,
         prompt: p.prompt,
+        modeId: session.modeId,
+        configOptions: session.configOptions,
         signal: turnSignal.signal,
         cwd: session.cwd,
         ...session.mcpServers ? { mcpServers: session.mcpServers } : {}
@@ -466,16 +497,25 @@ async function handleSessionPromptOp(ctx, id, params) {
       api
     );
   } catch (err) {
+    session.prompting = false;
     session.abort.signal.removeEventListener("abort", onCancel);
+    await Promise.all(pendingNotifications);
+    if (turnSignal.signal.aborted) {
+      await ctx.sendResult(id, { stopReason: "cancelled" });
+      return false;
+    }
     const { code, message, data } = errorToJsonRpc(err);
     await ctx.sendError(id, code, message, data);
     return false;
   }
   await Promise.all(pendingNotifications);
+  session.prompting = false;
   session.abort.signal.removeEventListener("abort", onCancel);
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await ctx.persist(session);
-  await ctx.sendResult(id, { stopReason: result.stopReason });
+  if (ctx.sessions.get(sessionId) === session) await ctx.persist(session);
+  await ctx.sendResult(id, {
+    stopReason: turnSignal.signal.aborted ? "cancelled" : result.stopReason
+  });
   return false;
 }
 async function handleSetModeOp(ctx, id, params) {
@@ -491,7 +531,11 @@ async function handleSetModeOp(ctx, id, params) {
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await ctx.sendNotification({
     sessionId,
-    update: { sessionUpdate: "current_mode_update", modeId }
+    update: {
+      sessionUpdate: "current_mode_update",
+      currentModeId: modeId,
+      modeId
+    }
   });
   await ctx.sendResult(id, {});
   return false;
@@ -502,21 +546,24 @@ async function handleSetConfigOptionOp(ctx, id, params) {
   const optionId = typeof p.configId === "string" ? p.configId : null;
   const value = typeof p.value === "string" ? p.value : null;
   const session = sessionId ? ctx.sessions.get(sessionId) : void 0;
-  const option = optionId ? ctx.configOptions.find((o) => o.id === optionId) : void 0;
+  const options = session?.configOptions ?? structuredClone([...ctx.configOptions]);
+  const option = optionId ? options.find((o) => o.id === optionId) : void 0;
   if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
     await ctx.sendError(id, -32602, "invalid sessionId, configId, or value");
     return false;
   }
   option.currentValue = value;
+  session.configOptions = options;
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await ctx.sendNotification({
     sessionId,
     update: {
       sessionUpdate: "config_option_update",
-      configOptions: [...ctx.configOptions]
+      configOptions: options
     }
   });
-  await ctx.sendResult(id, { configOptions: [...ctx.configOptions] });
+  await ctx.persist(session);
+  await ctx.sendResult(id, { configOptions: options });
   return false;
 }
 async function reportSkippedMcpServers(ctx, sessionId, skipped) {
@@ -558,6 +605,8 @@ var ACPProtocolHandler = class {
   // session/request_permission). Keyed by our own `srv_N` ids.
   pendingOut = /* @__PURE__ */ new Map();
   nextOutId = 1;
+  promptRequests = /* @__PURE__ */ new Map();
+  persistenceWrites = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.transport = opts.transport;
     this.defaultCwd = opts.defaultCwd;
@@ -583,20 +632,46 @@ var ACPProtocolHandler = class {
    */
   request(method, params, timeoutMs = 6e4) {
     const id = `srv_${this.nextOutId++}`;
-    return new Promise((resolve4, reject) => {
-      const timer = setTimeout(() => {
+    const sessionId = params?.sessionId;
+    const signal = sessionId ? this.sessions.get(sessionId)?.abort.signal : void 0;
+    return new Promise((resolve5, reject) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
         this.pendingOut.delete(id);
-        reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+      };
+      const fail = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const abort = () => {
+        fail(new Error("client request cancelled"));
+        void this.transport.send(toWire({ jsonrpc: "2.0", method: "$/cancel_request", params: { requestId: id } })).catch(() => {
+        });
+      };
+      const timer = setTimeout(() => {
+        fail(new Error(`${method} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pendingOut.set(id, { resolve: resolve4, reject, timer });
+      if (signal?.aborted) {
+        fail(new Error("client request cancelled"));
+        return;
+      }
+      signal?.addEventListener("abort", abort, { once: true });
+      this.pendingOut.set(id, {
+        resolve: (value) => {
+          cleanup();
+          resolve5(value);
+        },
+        reject: fail,
+        timer
+      });
       this.transport.send(toWire({ jsonrpc: "2.0", id, method, params })).catch((e) => {
-        clearTimeout(timer);
-        this.pendingOut.delete(id);
-        reject(e instanceof Error ? e : new Error(String(e)));
+        fail(e instanceof Error ? e : new Error(String(e)));
       });
     });
   }
   maybeResolvePending(m) {
+    if (m.result === void 0 && m.error === void 0) return;
     const id = m.id;
     if (typeof id !== "string") return;
     const pending = this.pendingOut.get(id);
@@ -616,6 +691,7 @@ var ACPProtocolHandler = class {
     if (typeof msg !== "object" || msg === null) return false;
     const m = msg;
     if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+      this.maybeResolvePending(msg);
       return false;
     }
     if (m.id !== void 0 && typeof m.method === "string") {
@@ -655,6 +731,7 @@ var ACPProtocolHandler = class {
       store: this.store,
       replayFor: this.replayFor,
       seedFor: this.seedFor,
+      disposeFor: this.disposeFor,
       onSessionNew: this.onSessionNew,
       allocId: () => this.allocId(),
       persist: (state, history) => this.persist(state, history),
@@ -692,14 +769,23 @@ var ACPProtocolHandler = class {
           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/prompt": {
+          const sessionId = params?.sessionId;
+          if (typeof sessionId === "string" && !this.sessions.get(sessionId)?.prompting) {
+            this.promptRequests.set(id, sessionId);
+          }
+          try {
+            return await handleSessionPromptOp(this.sessionContext(), id, params);
+          } finally {
+            this.promptRequests.delete(id);
+          }
+        }
         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);
+          return await this.handleSessionList(id, params);
         case "session/fork":
           return await handleSessionForkOp(this.sessionContext(), id, params);
         case "providers/list":
@@ -728,7 +814,12 @@ var ACPProtocolHandler = class {
     this.initialized = true;
     await this.sendResult(
       id,
-      buildInitializeResult(this.agentName, this.modes, this.configOptions)
+      buildInitializeResult(
+        this.agentName,
+        this.modes,
+        this.configOptions,
+        this.clientCapabilities
+      )
     );
     return false;
   }
@@ -737,29 +828,15 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleLogout(id, _params) {
-    await this.sendResult(id, {});
+    await this.sendError(
+      id,
+      -32601,
+      "logout is not supported; manage provider credentials with wstack auth"
+    );
     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();
-      const resumeServers = parseMcpServers(p.mcpServers);
-      if (resumeServers.length > 0) {
-        existing.mcpServers = resumeServers;
-      }
-      await this.sendResult(id, {
-        initialMode: {
-          currentModeId: existing.modeId,
-          availableModes: this.modes
-        }
-      });
-      return false;
-    }
-    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
-    return false;
+    return handleSessionLoadOp(this.sessionContext(), id, params, false);
   }
   async handleSessionClose(id, params) {
     const p = params ?? {};
@@ -782,14 +859,12 @@ var ACPProtocolHandler = class {
       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();
+    session?.abort.abort();
     this.sessions.delete(sessionId);
     this.disposeSession(sessionId);
+    await this.persistenceWrites.get(sessionId);
+    await this.store?.delete?.(sessionId);
     await this.sendResult(id, {});
     return false;
   }
@@ -816,12 +891,23 @@ var ACPProtocolHandler = class {
     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) => {
+  async handleSessionList(id, params) {
+    const p = params ?? {};
+    if (p.cwd != null && (typeof p.cwd !== "string" || !isAbsolute2(p.cwd)) || p.cursor != null) {
+      await this.sendError(id, -32602, "invalid cwd or cursor");
+      return false;
+    }
+    const known = new Map(this.sessions);
+    for (const entry of await this.store?.list?.() ?? []) {
+      if (known.has(entry.id)) continue;
+      const saved = await this.store?.load(entry.id);
+      if (saved?.cwd) known.set(entry.id, { ...saved, id: entry.id });
+    }
+    const sessions = Array.from(known.values()).filter((s) => typeof p.cwd !== "string" || s.cwd && resolve2(s.cwd) === resolve2(p.cwd)).map((s) => {
       const out = {
         sessionId: s.id,
         cwd: s.cwd,
-        updatedAt: s.updatedAt
+        updatedAt: s.updatedAt ?? ""
       };
       if (s.title !== void 0) out.title = s.title;
       return out;
@@ -844,6 +930,11 @@ var ACPProtocolHandler = class {
         return false;
       }
       case "$/cancel_request": {
+        const requestId = params?.requestId;
+        if (typeof requestId === "string" || typeof requestId === "number") {
+          const sessionId = this.promptRequests.get(requestId);
+          if (sessionId) this.sessions.get(sessionId)?.abort.abort();
+        }
         return false;
       }
       case "exit":
@@ -864,10 +955,18 @@ var ACPProtocolHandler = class {
   }
   async persist(state, history = void 0) {
     if (!this.store) return;
-    try {
-      await this.store.save(state, history ?? this.replayFor?.(state.id));
-    } catch {
-    }
+    const store = this.store;
+    const replay = history ?? this.replayFor?.(state.id);
+    const previous = this.persistenceWrites.get(state.id) ?? Promise.resolve();
+    const write = previous.then(() => store.save(state, replay)).then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.persistenceWrites.set(state.id, write);
+    await write;
+    if (this.persistenceWrites.get(state.id) === write) this.persistenceWrites.delete(state.id);
   }
   async sendError(id, code, message, data) {
     const error = { code, message };
@@ -927,9 +1026,9 @@ var StdioTransport = class {
   }
   send(msg) {
     if (this.closed) return Promise.resolve();
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const line = JSON.stringify(msg) + "\n";
-      this.stdout.write(line, "utf8", () => resolve4());
+      this.stdout.write(line, "utf8", () => resolve5());
     });
   }
   sendRaw(chunk) {
@@ -942,8 +1041,8 @@ var StdioTransport = class {
       return Promise.resolve(queued.message);
     }
     if (this.closed) return Promise.resolve(null);
-    return new Promise((resolve4) => {
-      this.resolveRead = resolve4;
+    return new Promise((resolve5) => {
+      this.resolveRead = resolve5;
     });
   }
   onMessage(handler) {
@@ -1012,9 +1111,9 @@ var StdioTransport = class {
   }
   dispatch(msg, chars = JSON.stringify(msg).length) {
     if (this.resolveRead) {
-      const resolve4 = this.resolveRead;
+      const resolve5 = this.resolveRead;
       this.resolveRead = null;
-      resolve4(msg);
+      resolve5(msg);
     } else {
       let claimed = false;
       for (const handler of this.claimHandlers) {
@@ -1086,7 +1185,7 @@ var ClientTransport = class {
       import("@wrongstack/core/utils"),
       import("node:os")
     ]);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const timeout = setTimeout(() => {
         const child2 = this.child;
         this.child = null;
@@ -1139,7 +1238,7 @@ var ClientTransport = class {
           if (settled) return;
           settled = true;
           clearTimeout(timeout);
-          resolve4();
+          resolve5();
         });
         return;
       }
@@ -1150,7 +1249,7 @@ var ClientTransport = class {
         child.stderr.on("data", (c) => this.onChildError(c));
         child.on("close", (code) => this.onChildClose(code));
         clearTimeout(timeout);
-        resolve4();
+        resolve5();
       };
       const waitForMarker = (chunk) => {
         this.buffer += chunk;
@@ -1169,11 +1268,11 @@ var ClientTransport = class {
   }
   send(msg) {
     if (!this.child) return Promise.reject(new Error("ClientTransport not started"));
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const line = JSON.stringify(msg) + "\n";
       this.child?.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve4();
+        else resolve5();
       });
     });
   }
@@ -1184,8 +1283,8 @@ var ClientTransport = class {
       return Promise.resolve(queued.message);
     }
     if (this.closed) return Promise.resolve(null);
-    return new Promise((resolve4) => {
-      this.resolveRead = resolve4;
+    return new Promise((resolve5) => {
+      this.resolveRead = resolve5;
     });
   }
   onMessage(handler) {
@@ -1256,6 +1355,7 @@ var ClientTransport = class {
     this.messageQueue.length = 0;
     this.queuedChars = 0;
     this.handlers.clear();
+    this.claimHandlers.clear();
     if (code !== 0 && code !== null) {
       writeErr(`[acp-child exited with code ${code}]
 `);
@@ -1263,20 +1363,31 @@ var ClientTransport = class {
   }
   dispatch(msg, chars = JSON.stringify(msg).length) {
     if (this.resolveRead) {
-      const resolve4 = this.resolveRead;
+      const resolve5 = this.resolveRead;
       this.resolveRead = null;
-      resolve4(msg);
-    } else if (this.handlers.size === 0) {
-      if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
-        writeErr(
-          `[acp-child message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters]
+      resolve5(msg);
+    } else {
+      let claimed = false;
+      for (const handler of this.claimHandlers) {
+        try {
+          if (handler(msg)) claimed = true;
+        } catch (err) {
+          writeErr(`[acp-child handler error] ${err}
+`);
+        }
+      }
+      if (!claimed && this.handlers.size === 0) {
+        if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
+          writeErr(
+            `[acp-child message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters]
 `
-        );
-        this.stop();
-        return;
+          );
+          this.stop();
+          return;
+        }
+        this.messageQueue.push({ message: msg, chars });
+        this.queuedChars += chars;
       }
-      this.messageQueue.push({ message: msg, chars });
-      this.queuedChars += chars;
     }
     for (const handler of this.handlers) {
       try {
@@ -1410,7 +1521,7 @@ function toolToPriority(tool) {
 import { createServer } from "node:http";
 import { isIP } from "node:net";
 import { fileURLToPath } from "node:url";
-import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { expandIPv6, isStandaloneBinary, writeErr as writeErr2 } from "@wrongstack/core/utils";
 import { timingSafeTokenEqual } from "@wrongstack/primitives";
 var LISTEN_RETRY_LIMIT = 5;
 var LISTEN_RETRY_BASE_MS = 25;
@@ -1456,15 +1567,30 @@ var WrongStackACPServer = class {
       this.transport.sendStartupMarker();
     }
     this.running = true;
+    const prompts = /* @__PURE__ */ new Set();
     try {
       while (this.running) {
         const msg = await this.transport.read();
         if (!msg) break;
+        if (msg.method === "session/prompt") {
+          const task = this.handler.handleMessage(msg).then(
+            () => {
+            },
+            (err) => {
+              writeErr2(`[wstack-acp] prompt dispatch failed: ${String(err)}
+`);
+            }
+          );
+          prompts.add(task);
+          void task.finally(() => prompts.delete(task));
+          continue;
+        }
         const terminal = await this.handler.handleMessage(msg);
         if (terminal) break;
       }
     } finally {
       this.handler.close();
+      await Promise.allSettled(prompts);
       this.transport.close();
     }
   }
@@ -1598,10 +1724,10 @@ var WrongStackACPServer = class {
   listenWithRetry(port, host, attempt = 0) {
     const server = this.httpServer;
     if (!server) return Promise.resolve();
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const onListening = () => {
         server.removeListener("error", onError);
-        resolve4();
+        resolve5();
       };
       const onError = (err) => {
         server.removeListener("listening", onListening);
@@ -1609,7 +1735,7 @@ var WrongStackACPServer = class {
         if (port === 0 && transient && attempt < LISTEN_RETRY_LIMIT) {
           const timer = setTimeout(
             () => {
-              this.listenWithRetry(port, host, attempt + 1).then(resolve4, reject);
+              this.listenWithRetry(port, host, attempt + 1).then(resolve5, reject);
             },
             LISTEN_RETRY_BASE_MS * (attempt + 1)
           );
@@ -1637,8 +1763,8 @@ var WrongStackACPServer = class {
     if (!server) return;
     for (const socket of this.httpSockets) socket.destroy();
     this.httpSockets.clear();
-    await new Promise((resolve4) => {
-      server.close(() => resolve4());
+    await new Promise((resolve5) => {
+      server.close(() => resolve5());
     });
   }
 };
@@ -1669,7 +1795,7 @@ async function main() {
   const server = new WrongStackACPServer();
   await server.start();
 }
-var isEntrypoint = process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
+var isEntrypoint = process.argv[1] !== void 0 && !isStandaloneBinary() && fileURLToPath(import.meta.url) === process.argv[1];
 if (isEntrypoint) {
   main().catch((err) => {
     writeErr2(`[wstack-acp fatal] ${err}
@@ -1678,93 +1804,472 @@ if (isEntrypoint) {
   });
 }
 
+// src/client/acp-late-session.ts
+var LATE_CANCEL_SEND_TIMEOUT_MS = 1e4;
+function cancelLateAcpSession(transport, createPromise) {
+  createPromise.then(async (lateId) => {
+    try {
+      await new Promise((resolve5, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error("late session/cancel send timed out"));
+        }, LATE_CANCEL_SEND_TIMEOUT_MS);
+        Promise.resolve(
+          transport.send({
+            jsonrpc: "2.0",
+            method: "session/cancel",
+            params: { sessionId: lateId }
+          })
+        ).then(
+          () => {
+            clearTimeout(timer);
+            resolve5();
+          },
+          (sendErr) => {
+            clearTimeout(timer);
+            reject(sendErr instanceof Error ? sendErr : new Error(String(sendErr)));
+          }
+        );
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "acp_session.late_cancel_failed",
+          sessionId: lateId,
+          message
+        })
+      );
+    }
+  }).catch((reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "acp_session.late_cancel_failed",
+        reason: message
+      })
+    );
+  });
+}
+
 // 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";
-import * as fsp2 from "node:fs/promises";
-import * as path2 from "node:path";
-var DEFAULT_FILE_OPERATIONS = {
-  stat: fsp2.stat,
-  readFile: fsp2.readFile,
-  writeFile: fsp2.writeFile,
-  realpath: fsp2.realpath,
-  rename: fsp2.rename,
-  unlink: fsp2.unlink
-};
-var DEFAULT_MAX_READ_BYTES = 5 * 1024 * 1024;
-var DEFAULT_MAX_WRITE_BYTES = 5 * 1024 * 1024;
-var FsError = class extends Error {
-  code;
-  path;
-  constructor(code, path5, message) {
+// src/client/acp-session-errors.ts
+var ACPSessionError = class extends Error {
+  kind;
+  cause;
+  constructor(kind, message, cause) {
     super(message);
-    this.name = "FsError";
-    this.code = code;
-    this.path = path5;
+    this.name = "ACPSessionError";
+    this.kind = kind;
+    this.cause = cause;
   }
 };
-var FileServer = class {
-  root;
-  realRoot;
-  timeoutMs;
-  maxReadBytes;
-  maxWriteBytes;
-  operations;
-  constructor(opts) {
-    this.root = path2.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;
+function isJsonRpcError(v) {
+  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
+}
+function isAuthRequiredError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
+  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
+  if (!cause || typeof cause !== "object") return false;
+  const data = cause.data;
+  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
+  if (data && typeof data === "object") {
+    const d = data;
+    if (d.authRequired === true) return true;
+    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
   }
-  /** Read a text file. Returns the content as a string. */
-  async readTextFile(params) {
-    const safe = await this.resolveInside(params.path);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    try {
-      const stat3 = await this.operations.stat(safe).catch((err) => {
-        throw mapFsError(err, safe);
-      });
-      if (stat3.size > this.maxReadBytes) {
-        throw new FsError(
-          "TOO_LARGE",
-          safe,
-          `file is ${stat3.size} bytes, max read is ${this.maxReadBytes} bytes`
-        );
-      }
-      const content = await this.operations.readFile(safe, {
-        encoding: "utf8",
-        signal: controller.signal
-      });
-      return { content };
-    } catch (err) {
-      if (err instanceof FsError) throw err;
-      if (controller.signal.aborted) {
-        throw new FsError("TIMEOUT", safe, `readTextFile timed out after ${this.timeoutMs}ms`);
-      }
-      throw mapFsError(err, safe);
-    } finally {
-      clearTimeout(timer);
-    }
+  return false;
+}
+
+// src/client/acp-session-ops.ts
+function filterMcpServers(agentCapabilities, servers) {
+  if (!servers || servers.length === 0) return [];
+  const mcpCaps = agentCapabilities.mcpCapabilities ?? {};
+  return servers.filter((s) => {
+    if ("type" in s && s.type === "http") return mcpCaps.http === true;
+    if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
+    return true;
+  });
+}
+async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.loadSession) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/load (loadSession capability not advertised)"
+    );
   }
-  /** Write a text file. Atomic via write-then-rename. */
-  async writeTextFile(params) {
-    if (typeof params.content !== "string") {
-      throw new FsError("INVALID_PATH", params.path, "content must be a string");
-    }
-    const byteLength = Buffer.byteLength(params.content, "utf8");
-    if (byteLength > this.maxWriteBytes) {
-      throw new FsError(
-        "TOO_LARGE",
-        params.path,
-        `content is ${byteLength} bytes, max write is ${this.maxWriteBytes} bytes`
+  if (ctx.sessionId && ctx.sessionId !== sessionId) {
+    await ctx.closeSession();
+  }
+  ctx.resetScratch();
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/load", {
+    sessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
+  }
+  ctx.setSessionId(sessionId);
+}
+async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.resume) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/resume (sessionCapabilities.resume not advertised)"
+    );
+  }
+  if (ctx.sessionId && ctx.sessionId !== sessionId) {
+    await ctx.closeSession();
+  }
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/resume", {
+    sessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/resume failed: ${result.message}`, result);
+  }
+  ctx.setSessionId(sessionId);
+}
+async function executeListSessions(ctx, cursor, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.list) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/list (sessionCapabilities.list not advertised)"
+    );
+  }
+  const id = ctx.allocId();
+  const params = {};
+  if (cursor !== void 0) params.cursor = cursor;
+  if (cwd !== void 0) params.cwd = cwd;
+  const result = await ctx.sendRequest(id, "session/list", params);
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
+  }
+  const r = result;
+  return {
+    sessions: r.sessions ?? [],
+    nextCursor: r.nextCursor
+  };
+}
+async function executeDeleteSession(ctx, sessionId) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.delete) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/delete (sessionCapabilities.delete not advertised)"
+    );
+  }
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/delete", { sessionId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/delete failed: ${result.message}`, result);
+  }
+  if (ctx.sessionId === sessionId) {
+    ctx.setSessionId(null);
+  }
+}
+async function executeForkSession(ctx, sourceSessionId, cwd, mcpServers) {
+  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/fork", {
+    sessionId: sourceSessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    ...servers.length > 0 ? { mcpServers: servers } : {}
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
+  }
+  const newId = result.sessionId;
+  if (typeof newId !== "string" || !newId) {
+    throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
+  }
+  return newId;
+}
+async function executeSetMode(ctx, sessionId, modeId) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/set_mode", { sessionId, modeId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/set_mode failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeSetConfigOption(ctx, sessionId, configId, value) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/set_config_option", {
+    sessionId,
+    configId,
+    value
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/set_config_option failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeListProviders(ctx) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/list", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `providers/list failed: ${result.message}`, result);
+  }
+  const r = result;
+  return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+}
+async function executeSetProvider(ctx, providerId, config) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
+  }
+}
+async function executeDisableProvider(ctx) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/disable", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `providers/disable failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeMcpMessage(ctx, connectionId, message) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "mcp/message", { connectionId, message });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
+  }
+  return result;
+}
+async function executeCreateSession(ctx) {
+  const servers = filterMcpServers(ctx.agentCapabilities, ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/new", {
+    cwd: ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "session_create_failed",
+      `session/new failed: ${result.message}`,
+      result
+    );
+  }
+  const sessionId = result.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    throw new ACPSessionError("protocol_error", "session/new returned no sessionId", result);
+  }
+  return sessionId;
+}
+
+// src/client/acp-session-auth.ts
+async function authenticate(host, methodId) {
+  if (host.state === "closed") {
+    throw new ACPSessionError("closed", "session is closed");
+  }
+  if (host.state !== "ready" && host.state !== "authenticated") {
+    throw new ACPSessionError(
+      "protocol_error",
+      `authenticate called in state=${host.state} (expected 'ready')`
+    );
+  }
+  if (host.state === "authenticated") return;
+  if (!host.authMethods.some((m) => m.id === methodId)) {
+    throw new ACPSessionError(
+      "auth_failed",
+      `auth method "${methodId}" not in advertised methods: ${host.authMethods.map((m) => m.id).join(", ")}`
+    );
+  }
+  if (host.authMethods.find((m) => m.id === methodId)?.type === "terminal") {
+    throw new ACPSessionError(
+      "auth_failed",
+      "Terminal authentication requires interactive login followed by reconnect; it cannot use authenticate"
+    );
+  }
+  const id = host.allocId();
+  const result = await host.sendRequest(id, "authenticate", { methodId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
+  }
+  host.state = "authenticated";
+}
+async function logout(host) {
+  if (host.state === "closed") {
+    throw new ACPSessionError("closed", "session is closed");
+  }
+  if (!host.agentCapabilities.auth?.logout) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support logout (auth.logout capability not advertised)"
+    );
+  }
+  const id = host.allocId();
+  const result = await host.sendRequest(id, "logout", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
+  }
+  host.state = "ready";
+}
+async function createSessionWithAuth(host) {
+  try {
+    return await executeCreateSession(host.opContext());
+  } catch (err) {
+    if (host.state === "authenticated" || !isAuthRequiredError(err)) {
+      throw err instanceof ACPSessionError ? err : new ACPSessionError(
+        "session_create_failed",
+        err instanceof Error ? err.message : String(err),
+        err
+      );
+    }
+    await host.ensureAuthenticated();
+    return executeCreateSession(host.opContext());
+  }
+}
+async function ensureAuthenticated(host) {
+  if (host.state === "authenticated") return;
+  if (host.authMethods.length === 0) {
+    throw new ACPSessionError(
+      "auth_failed",
+      "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
+    );
+  }
+  const inProcess = host.authMethods.find(
+    (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
+  );
+  if (inProcess) {
+    await host.authenticate(inProcess.id);
+    return;
+  }
+  const terminal = host.authMethods.find((m) => m.type === "terminal");
+  const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
+  const setup = setupArgs !== void 0 ? `${host.opts.command}${host.opts.args?.length ? ` ${host.opts.args.join(" ")}` : ""} ${setupArgs}` : `${host.opts.command}${host.opts.args?.length ? ` ${host.opts.args.join(" ")}` : ""}`;
+  throw new ACPSessionError(
+    "auth_failed",
+    `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
+  );
+}
+
+// src/client/file-server.ts
+import { randomBytes } from "node:crypto";
+import { realpathSync } from "node:fs";
+import * as fsp2 from "node:fs/promises";
+import * as path2 from "node:path";
+var DEFAULT_FILE_OPERATIONS = {
+  stat: fsp2.stat,
+  readFile: fsp2.readFile,
+  writeFile: fsp2.writeFile,
+  realpath: fsp2.realpath,
+  rename: fsp2.rename,
+  unlink: fsp2.unlink
+};
+var DEFAULT_MAX_READ_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_WRITE_BYTES = 5 * 1024 * 1024;
+var FsError = class extends Error {
+  code;
+  path;
+  constructor(code, path5, message) {
+    super(message);
+    this.name = "FsError";
+    this.code = code;
+    this.path = path5;
+  }
+};
+var FileServer = class {
+  root;
+  realRoot;
+  timeoutMs;
+  maxReadBytes;
+  maxWriteBytes;
+  operations;
+  constructor(opts) {
+    this.root = path2.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) {
+    if (params.line != null && (!Number.isSafeInteger(params.line) || params.line < 1) || params.limit != null && (!Number.isSafeInteger(params.limit) || params.limit < 0)) {
+      throw new FsError(
+        "INVALID_PATH",
+        params.path,
+        "line must be a positive integer and limit a non-negative integer"
+      );
+    }
+    const safe = await this.resolveInside(params.path);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const stat3 = await this.operations.stat(safe).catch((err) => {
+        throw mapFsError(err, safe);
+      });
+      if (stat3.size > this.maxReadBytes) {
+        throw new FsError(
+          "TOO_LARGE",
+          safe,
+          `file is ${stat3.size} bytes, max read is ${this.maxReadBytes} bytes`
+        );
+      }
+      const content = await this.operations.readFile(safe, {
+        encoding: "utf8",
+        signal: controller.signal
+      });
+      if (params.line == null && params.limit == null) return { content };
+      const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+      const start = (params.line ?? 1) - 1;
+      return {
+        content: lines.slice(start, params.limit == null ? void 0 : start + params.limit).join("")
+      };
+    } catch (err) {
+      if (err instanceof FsError) throw err;
+      if (controller.signal.aborted) {
+        throw new FsError("TIMEOUT", safe, `readTextFile timed out after ${this.timeoutMs}ms`);
+      }
+      throw mapFsError(err, safe);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Write a text file. Atomic via write-then-rename. */
+  async writeTextFile(params) {
+    if (typeof params.content !== "string") {
+      throw new FsError("INVALID_PATH", params.path, "content must be a string");
+    }
+    const byteLength = Buffer.byteLength(params.content, "utf8");
+    if (byteLength > this.maxWriteBytes) {
+      throw new FsError(
+        "TOO_LARGE",
+        params.path,
+        `content is ${byteLength} bytes, max write is ${this.maxWriteBytes} bytes`
       );
     }
     const safe = await this.resolveInside(params.path);
@@ -1848,7 +2353,8 @@ var FileServer = class {
         throw mapFsError(err, resolvedPath);
       }
       const normReal = isWindows ? real.toLowerCase() : real;
-      if (normReal === normRealRoot || normReal.startsWith(normRealRoot + path2.sep)) return;
+      const realRootWithSep = normRealRoot.endsWith(path2.sep) ? normRealRoot : normRealRoot + path2.sep;
+      if (normReal === normRealRoot || normReal.startsWith(realRootWithSep)) return;
       throw new FsError(
         "OUTSIDE_ROOT",
         resolvedPath,
@@ -1897,9 +2403,12 @@ async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbac
     );
     await sender.sendResult(id, { outcome });
   } catch (err) {
+    if (isAbortLikeError(err)) {
+      await sender.sendResult(id, { outcome: { outcome: "cancelled" } });
+      return;
+    }
     const message = err instanceof Error ? err.message : String(err);
-    const code = isAbortLikeError(err) ? -32800 : -32603;
-    await sender.sendErrorResponse(id, code, `permission policy failed: ${message}`);
+    await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
   }
 }
 async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, callbackOptions = {}) {
@@ -1935,7 +2444,9 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, cal
     if (msg.method === "fs/read_text_file") {
       const result = await fileServer.readTextFile({
         sessionId: params.sessionId ?? "",
-        path: params.path
+        path: params.path,
+        line: params.line,
+        limit: params.limit
       });
       await sender.sendResult(id, result);
     } else {
@@ -2037,336 +2548,105 @@ async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions)
   try {
     const outcome = await runPermissionWithDeadline(
       permissionPolicy,
-      {
-        toolCall: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: partial.toolCallId,
-          title: partial.title,
-          kind: partial.kind,
-          status: "pending",
-          rawInput: partial.rawInput
-        },
-        options: [
-          { optionId: "allow", name: "Allow", kind: "allow_once" },
-          { optionId: "reject", name: "Reject", kind: "reject_once" }
-        ]
-      },
-      callbackOptions
-    );
-    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);
-  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) {
-      abort();
-    } else {
-      callbackOptions.signal.addEventListener("abort", abort, { once: true });
-      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
-    }
-  }
-  try {
-    return await Promise.race([
-      permissionPolicy({
-        toolCall: call.toolCall,
-        options: call.options,
-        signal: controller.signal
-      }),
-      rejectOnAbort(controller.signal)
-    ]);
-  } finally {
-    if (timer !== null) clearTimeout(timer);
-    removeAbort?.();
-  }
-}
-function rejectOnAbort(signal) {
-  return new Promise((_, reject) => {
-    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
-    if (signal.aborted) {
-      rejectAbort();
-      return;
-    }
-    signal.addEventListener("abort", rejectAbort, { once: true });
-  });
-}
-function isAbortLikeError(err) {
-  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
-}
-function resolvePermissionDeadline(value) {
-  if (value === Number.POSITIVE_INFINITY) return null;
-  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(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-errors.ts
-var ACPSessionError = class extends Error {
-  kind;
-  cause;
-  constructor(kind, message, cause) {
-    super(message);
-    this.name = "ACPSessionError";
-    this.kind = kind;
-    this.cause = cause;
-  }
-};
-function isJsonRpcError(v) {
-  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
-}
-function isAuthRequiredError(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
-  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
-  if (!cause || typeof cause !== "object") return false;
-  const data = cause.data;
-  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
-  if (data && typeof data === "object") {
-    const d = data;
-    if (d.authRequired === true) return true;
-    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
-  }
-  return false;
-}
-
-// src/client/acp-session-ops.ts
-function filterMcpServers(agentCapabilities, servers) {
-  if (!servers || servers.length === 0) return [];
-  const mcpCaps = agentCapabilities.mcpCapabilities ?? {};
-  return servers.filter((s) => {
-    if ("type" in s && s.type === "http") return mcpCaps.http === true;
-    if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
-    return true;
-  });
-}
-async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.loadSession) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/load (loadSession capability not advertised)"
-    );
-  }
-  if (ctx.sessionId) {
-    await ctx.closeSession();
-  }
-  ctx.resetScratch();
-  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/load", {
-    sessionId,
-    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
-    mcpServers: servers
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
-  }
-  ctx.setSessionId(sessionId);
-}
-async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.sessionCapabilities?.resume) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/resume (sessionCapabilities.resume not advertised)"
-    );
-  }
-  if (ctx.sessionId) {
-    await ctx.closeSession();
-  }
-  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/resume", {
-    sessionId,
-    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
-    mcpServers: servers
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/resume failed: ${result.message}`, result);
-  }
-  ctx.setSessionId(sessionId);
-}
-async function executeListSessions(ctx, cursor, cwd) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.sessionCapabilities?.list) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/list (sessionCapabilities.list not advertised)"
-    );
-  }
-  const id = ctx.allocId();
-  const params = {};
-  if (cursor !== void 0) params.cursor = cursor;
-  if (cwd !== void 0) params.cwd = cwd;
-  const result = await ctx.sendRequest(id, "session/list", params);
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
-  }
-  const r = result;
-  return {
-    sessions: r.sessions ?? [],
-    nextCursor: r.nextCursor
-  };
-}
-async function executeDeleteSession(ctx, sessionId) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  if (!ctx.agentCapabilities.sessionCapabilities?.delete) {
-    throw new ACPSessionError(
-      "unsupported_capability",
-      "agent does not support session/delete (sessionCapabilities.delete not advertised)"
+      {
+        toolCall: {
+          sessionUpdate: "tool_call_update",
+          toolCallId: partial.toolCallId,
+          title: partial.title,
+          kind: partial.kind,
+          status: "pending",
+          rawInput: partial.rawInput
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" }
+        ]
+      },
+      callbackOptions
     );
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
+  } catch (err) {
+    return isAbortLikeError(err) ? "cancelled" : "denied";
   }
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/delete", { sessionId });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/delete failed: ${result.message}`, result);
+}
+async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
+  const timeoutMs = resolvePermissionDeadline(callbackOptions.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) {
+      abort();
+    } else {
+      callbackOptions.signal.addEventListener("abort", abort, { once: true });
+      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
+    }
   }
-  if (ctx.sessionId === sessionId) {
-    ctx.setSessionId(null);
+  try {
+    return await Promise.race([
+      permissionPolicy({
+        toolCall: call.toolCall,
+        options: call.options,
+        signal: controller.signal
+      }),
+      rejectOnAbort(controller.signal)
+    ]);
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+    removeAbort?.();
   }
 }
-async function executeForkSession(ctx, sourceSessionId, cwd, mcpServers) {
-  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/fork", {
-    sessionId: sourceSessionId,
-    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
-    ...servers.length > 0 ? { mcpServers: servers } : {}
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
+    if (signal.aborted) {
+      rejectAbort();
+      return;
+    }
+    signal.addEventListener("abort", rejectAbort, { once: true });
   });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
-  }
-  const newId = result.sessionId;
-  if (typeof newId !== "string" || !newId) {
-    throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
-  }
-  return newId;
 }
-async function executeSetMode(ctx, sessionId, modeId) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/set_mode", { sessionId, modeId });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "prompt_failed",
-      `session/set_mode failed: ${result.message}`,
-      result
-    );
-  }
+function isAbortLikeError(err) {
+  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
 }
-async function executeSetConfigOption(ctx, sessionId, configId, value) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/set_config_option", {
-    sessionId,
-    configId,
-    value
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "prompt_failed",
-      `session/set_config_option failed: ${result.message}`,
-      result
-    );
-  }
+function resolvePermissionDeadline(value) {
+  if (value === Number.POSITIVE_INFINITY) return null;
+  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  return DEFAULT_PERMISSION_TIMEOUT_MS;
 }
-async function executeListProviders(ctx) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "providers/list", {});
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `providers/list failed: ${result.message}`, result);
-  }
-  const r = result;
-  return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+
+// src/client/acp-session-content.ts
+function textContent(text) {
+  return { type: "text", text };
 }
-async function executeSetProvider(ctx, providerId, config) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
-  }
+function imageContent(mimeType, data) {
+  return { type: "image", mimeType, data };
 }
-async function executeDisableProvider(ctx) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "providers/disable", {});
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "prompt_failed",
-      `providers/disable failed: ${result.message}`,
-      result
-    );
-  }
+function audioContent(mimeType, data) {
+  return { type: "audio", mimeType, data };
 }
-async function executeMcpMessage(ctx, connectionId, message) {
-  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "mcp/message", { connectionId, message });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
+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 result;
+  return "";
 }
-async function executeCreateSession(ctx) {
-  const servers = filterMcpServers(ctx.agentCapabilities, ctx.opts.mcpServers);
-  const id = ctx.allocId();
-  const result = await ctx.sendRequest(id, "session/new", {
-    cwd: ctx.opts.cwd ?? ctx.opts.projectRoot,
-    mcpServers: servers
-  });
-  if (isJsonRpcError(result)) {
-    throw new ACPSessionError(
-      "session_create_failed",
-      `session/new failed: ${result.message}`,
-      result
-    );
-  }
-  const sessionId = result.sessionId;
-  if (typeof sessionId !== "string" || sessionId.length === 0) {
-    throw new ACPSessionError("protocol_error", "session/new returned no sessionId", result);
-  }
-  return sessionId;
+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
@@ -2387,6 +2667,7 @@ function handleAcpSessionUpdate(msg, scratch, emitProgress) {
       }
       return;
     }
+    case "agent_thought_chunk":
     case "thought_chunk": {
       const text = extractText(u.content);
       if (text) {
@@ -2584,7 +2865,7 @@ var TerminalServer = class {
       truncated: false,
       exitStatus: void 0,
       timeoutHandle: null,
-      exitPromise: new Promise((resolve4) => {
+      exitPromise: new Promise((resolve5) => {
         proc.on("close", (code, signalName) => {
           if (state.timeoutHandle) {
             clearTimeout(state.timeoutHandle);
@@ -2595,7 +2876,7 @@ var TerminalServer = class {
             signal: typeof signalName === "string" ? signalName : null
           };
           state.exitStatus = exitStatus;
-          resolve4(exitStatus);
+          resolve5(exitStatus);
         });
         proc.on("error", (err) => {
           if (state.timeoutHandle) {
@@ -2614,7 +2895,7 @@ var TerminalServer = class {
           }
           state.outputChunks.push(errorOutput);
           state.retainedBytes = errorOutput.length;
-          resolve4(exitStatus);
+          resolve5(exitStatus);
         });
       })
     };
@@ -2921,7 +3202,7 @@ var WebSocketClientTransport = class {
       );
     }
     const timeoutMs = this.opts.handshakeTimeoutMs ?? 3e4;
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const ws = new WS(this.opts.url, this.opts.protocols);
       this.ws = ws;
       const timer = setTimeout(() => {
@@ -2937,7 +3218,7 @@ var WebSocketClientTransport = class {
         }
         pending.reject(new Error(`WebSocket failed to open within ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pendingStart = { resolve: resolve4, reject, timer };
+      this.pendingStart = { resolve: resolve5, reject, timer };
       ws.addEventListener("open", () => {
         const pending = this.pendingStart;
         if (pending === null) return;
@@ -3052,7 +3333,6 @@ function finitePositiveLimit(value, fallback) {
 }
 
 // src/client/acp-session.ts
-var LATE_CANCEL_SEND_TIMEOUT_MS = 1e4;
 var ACPSession = class _ACPSession {
   transport;
   fileServer;
@@ -3222,7 +3502,7 @@ var ACPSession = class _ACPSession {
       throw new ACPSessionError("protocol_error", "initialize returned no protocolVersion");
     }
     const r = result;
-    if (r.protocolVersion > ACP_PROTOCOL_VERSION) {
+    if (r.protocolVersion !== ACP_PROTOCOL_VERSION) {
       throw new ACPSessionError(
         "unsupported_capability",
         `agent requires protocolVersion=${r.protocolVersion}, client supports up to ${ACP_PROTOCOL_VERSION}`
@@ -3242,49 +3522,14 @@ var ACPSession = class _ACPSession {
    * Call this AFTER start() and BEFORE any session/new call.
    */
   async authenticate(methodId) {
-    if (this.state === "closed") {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (this.state !== "ready" && this.state !== "authenticated") {
-      throw new ACPSessionError(
-        "protocol_error",
-        `authenticate called in state=${this.state} (expected 'ready')`
-      );
-    }
-    if (this.state === "authenticated") return;
-    if (!this.authMethods.some((m) => m.id === methodId)) {
-      throw new ACPSessionError(
-        "auth_failed",
-        `auth method "${methodId}" not in advertised methods: ${this.authMethods.map((m) => m.id).join(", ")}`
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "authenticate", { methodId });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
-    }
-    this.state = "authenticated";
+    return authenticate(this.acpSessionAuthHost(), methodId);
   }
   /**
    * Log out from the current authenticated session.
    * Only callable if the agent advertises `auth.logout` capability.
    */
   async logout() {
-    if (this.state === "closed") {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.auth?.logout) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support logout (auth.logout capability not advertised)"
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "logout", {});
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
-    }
-    this.state = "ready";
+    return logout(this.acpSessionAuthHost());
   }
   // ──────────────────────────────────────────────────────────────────────
   // Session management delegation
@@ -3353,6 +3598,16 @@ var ACPSession = class _ACPSession {
     if (signal.aborted) {
       return emptyRunResult("cancelled");
     }
+    const caps = this.agentCapabilities.promptCapabilities;
+    for (const block of blocks) {
+      const supported = block.type === "image" ? caps?.image : block.type === "audio" ? caps?.audio : block.type === "resource" ? caps?.embeddedContext : true;
+      if (supported !== true) {
+        throw new ACPSessionError(
+          "unsupported_capability",
+          `agent does not support ${block.type} prompt content`
+        );
+      }
+    }
     let cancelled = false;
     this.promptCallbackAbort = new AbortController();
     const onAbort = () => {
@@ -3487,50 +3742,7 @@ var ACPSession = class _ACPSession {
    * being silently swallowed.
    */
   cancelLateSession(createPromise) {
-    createPromise.then(async (lateId) => {
-      try {
-        await new Promise((resolve4, reject) => {
-          const timer = setTimeout(() => {
-            reject(new Error("late session/cancel send timed out"));
-          }, LATE_CANCEL_SEND_TIMEOUT_MS);
-          Promise.resolve(
-            this.transport.send({
-              jsonrpc: "2.0",
-              method: "session/cancel",
-              params: { sessionId: lateId }
-            })
-          ).then(
-            () => {
-              clearTimeout(timer);
-              resolve4();
-            },
-            (sendErr) => {
-              clearTimeout(timer);
-              reject(sendErr instanceof Error ? sendErr : new Error(String(sendErr)));
-            }
-          );
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(
-          JSON.stringify({
-            level: "warn",
-            event: "acp_session.late_cancel_failed",
-            sessionId: lateId,
-            message
-          })
-        );
-      }
-    }).catch((reason) => {
-      const message = reason instanceof Error ? reason.message : String(reason);
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "acp_session.late_cancel_failed",
-          reason: message
-        })
-      );
-    });
+    cancelLateAcpSession(this.transport, createPromise);
   }
   async closeSession() {
     if (!this.sessionId) return;
@@ -3577,10 +3789,16 @@ var ACPSession = class _ACPSession {
   // Wire layer
   // ────────────────────────────────────────────────────────────────────
   allocId() {
-    return this.nextId++;
+    let candidate = Number.isSafeInteger(this.nextId) && this.nextId >= 1 ? this.nextId : 1;
+    for (let probe = 0; probe <= this.pending.size; probe++) {
+      this.nextId = candidate >= Number.MAX_SAFE_INTEGER ? 1 : candidate + 1;
+      if (!this.pending.has(candidate)) return candidate;
+      candidate = this.nextId;
+    }
+    throw new ACPSessionError("protocol_error", "no JSON-RPC request id is available");
   }
   async sendRequest(id, method, params, timeoutMs) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const effectiveTimeout = timeoutMs ?? this.timeoutMs;
       const handle = setTimeout(() => {
         this.pending.delete(id);
@@ -3590,7 +3808,7 @@ var ACPSession = class _ACPSession {
       }, effectiveTimeout);
       this.pending.set(id, {
         method,
-        resolve: resolve4,
+        resolve: resolve5,
         reject,
         timeoutMs: effectiveTimeout,
         timeoutHandle: handle
@@ -3609,19 +3827,7 @@ var ACPSession = class _ACPSession {
    * `authMethods`; we do not pop OAuth on every spawn.
    */
   async createSessionWithAuth() {
-    try {
-      return await executeCreateSession(this.opContext());
-    } catch (err) {
-      if (this.state === "authenticated" || !isAuthRequiredError(err)) {
-        throw err instanceof ACPSessionError ? err : new ACPSessionError(
-          "session_create_failed",
-          err instanceof Error ? err.message : String(err),
-          err
-        );
-      }
-      await this.ensureAuthenticated();
-      return executeCreateSession(this.opContext());
-    }
+    return createSessionWithAuth(this.acpSessionAuthHost());
   }
   /**
    * Pick a non-terminal auth method and run `authenticate`. Terminal-only
@@ -3629,27 +3835,7 @@ var ACPSession = class _ACPSession {
    * we refuse rather than hang a TUI inside the JSON-RPC child.
    */
   async ensureAuthenticated() {
-    if (this.state === "authenticated") return;
-    if (this.authMethods.length === 0) {
-      throw new ACPSessionError(
-        "auth_failed",
-        "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
-      );
-    }
-    const inProcess = this.authMethods.find(
-      (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
-    );
-    if (inProcess) {
-      await this.authenticate(inProcess.id);
-      return;
-    }
-    const terminal = this.authMethods.find((m) => m.type === "terminal");
-    const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
-    const setup = setupArgs !== void 0 ? `${this.opts.command} ${setupArgs}` : `${this.opts.command}${this.opts.args?.length ? ` ${this.opts.args.join(" ")}` : ""}`;
-    throw new ACPSessionError(
-      "auth_failed",
-      `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
-    );
+    return ensureAuthenticated(this.acpSessionAuthHost());
   }
   sendResult(id, result) {
     return this.transport.send({ jsonrpc: "2.0", id, result });
@@ -3727,7 +3913,7 @@ var ACPSession = class _ACPSession {
     }
     if (isBestEffortAckMethod(msg.method)) {
       if (msg.id !== void 0) {
-        this.sendResult(msg.id, {}).catch(() => {
+        this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(() => {
         });
       }
       return;
@@ -3736,6 +3922,13 @@ var ACPSession = class _ACPSession {
       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",
@@ -3758,6 +3951,29 @@ var ACPSession = class _ACPSession {
   resetScratch() {
     this.scratch = createSessionScratch();
   }
+  acpSessionAuthHost() {
+    const self = this;
+    return {
+      get state() {
+        return self.state;
+      },
+      set state(value) {
+        self.state = value;
+      },
+      get authMethods() {
+        return self.authMethods;
+      },
+      allocId: (...args) => this.allocId(...args),
+      sendRequest: (...args) => this.sendRequest(...args),
+      get agentCapabilities() {
+        return self.agentCapabilities;
+      },
+      opContext: (...args) => this.opContext(...args),
+      ensureAuthenticated: (...args) => this.ensureAuthenticated(...args),
+      authenticate: (...args) => this.authenticate(...args),
+      opts: this.opts
+    };
+  }
 };
 
 // src/client/tool-translator.ts
@@ -3809,12 +4025,12 @@ var ToolTranslator = class {
       id: callId,
       params: { name, arguments: args }
     });
-    return new Promise((resolve4, reject) => {
+    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: resolve4, reject, timeout });
+      this.pending.set(callId, { resolve: resolve5, reject, timeout });
     });
   }
   cancelAll() {
@@ -4637,7 +4853,7 @@ async function probeWithBound(items, worker, limit) {
 }
 async function defaultProbe(desc, timeoutMs, spawnProcess = spawn2, platform = process.platform) {
   const start = Date.now();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
     let stdout = "";
     let stderr = "";
@@ -4650,7 +4866,7 @@ async function defaultProbe(desc, timeoutMs, spawnProcess = spawn2, platform = p
         }
       } catch {
       }
-      resolve4(result);
+      resolve5(result);
     };
     let child;
     try {