@wrongstack/acp 1.0.17 → 1.0.24

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,6 +1804,55 @@ 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";
@@ -1725,6 +1900,13 @@ var FileServer = class {
   }
   /** 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);
@@ -1743,7 +1925,12 @@ var FileServer = class {
         encoding: "utf8",
         signal: controller.signal
       });
-      return { content };
+      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) {
@@ -1848,7 +2035,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 +2085,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 +2126,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 {
@@ -2185,7 +2378,7 @@ async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
       "agent does not support session/load (loadSession capability not advertised)"
     );
   }
-  if (ctx.sessionId) {
+  if (ctx.sessionId && ctx.sessionId !== sessionId) {
     await ctx.closeSession();
   }
   ctx.resetScratch();
@@ -2209,7 +2402,7 @@ async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
       "agent does not support session/resume (sessionCapabilities.resume not advertised)"
     );
   }
-  if (ctx.sessionId) {
+  if (ctx.sessionId && ctx.sessionId !== sessionId) {
     await ctx.closeSession();
   }
   const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
@@ -2387,6 +2580,7 @@ function handleAcpSessionUpdate(msg, scratch, emitProgress) {
       }
       return;
     }
+    case "agent_thought_chunk":
     case "thought_chunk": {
       const text = extractText(u.content);
       if (text) {
@@ -2536,7 +2730,9 @@ var TerminalServer = class {
     this.instanceId = `term_srv_${randomBytes2(4).toString("hex")}`;
     this.maxTerminals = this.clampFiniteInt(opts.maxTerminals, 32);
     this.abortSignal = opts.signal;
-    if (opts.signal) {
+    if (opts.signal?.aborted) {
+      this.dispose();
+    } else if (opts.signal) {
       opts.signal.addEventListener("abort", this.abortHandler, { once: true });
     }
   }
@@ -2582,7 +2778,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);
@@ -2593,7 +2789,7 @@ var TerminalServer = class {
             signal: typeof signalName === "string" ? signalName : null
           };
           state.exitStatus = exitStatus;
-          resolve4(exitStatus);
+          resolve5(exitStatus);
         });
         proc.on("error", (err) => {
           if (state.timeoutHandle) {
@@ -2612,7 +2808,7 @@ var TerminalServer = class {
           }
           state.outputChunks.push(errorOutput);
           state.retainedBytes = errorOutput.length;
-          resolve4(exitStatus);
+          resolve5(exitStatus);
         });
       })
     };
@@ -2919,7 +3115,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(() => {
@@ -2935,7 +3131,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;
@@ -3050,7 +3246,6 @@ function finitePositiveLimit(value, fallback) {
 }
 
 // src/client/acp-session.ts
-var LATE_CANCEL_SEND_TIMEOUT_MS = 1e4;
 var ACPSession = class _ACPSession {
   transport;
   fileServer;
@@ -3220,7 +3415,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}`
@@ -3256,6 +3451,12 @@ var ACPSession = class _ACPSession {
         `auth method "${methodId}" not in advertised methods: ${this.authMethods.map((m) => m.id).join(", ")}`
       );
     }
+    if (this.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 = this.allocId();
     const result = await this.sendRequest(id, "authenticate", { methodId });
     if (isJsonRpcError(result)) {
@@ -3351,6 +3552,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 = () => {
@@ -3485,50 +3696,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;
@@ -3575,10 +3743,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);
@@ -3588,7 +3762,7 @@ var ACPSession = class _ACPSession {
       }, effectiveTimeout);
       this.pending.set(id, {
         method,
-        resolve: resolve4,
+        resolve: resolve5,
         reject,
         timeoutMs: effectiveTimeout,
         timeoutHandle: handle
@@ -3643,7 +3817,7 @@ var ACPSession = class _ACPSession {
     }
     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(" ")}` : ""}`;
+    const setup = setupArgs !== void 0 ? `${this.opts.command}${this.opts.args?.length ? ` ${this.opts.args.join(" ")}` : ""} ${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.`
@@ -3725,7 +3899,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;
@@ -3734,6 +3908,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",
@@ -3807,12 +3988,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() {
@@ -4635,7 +4816,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 = "";
@@ -4648,7 +4829,7 @@ async function defaultProbe(desc, timeoutMs, spawnProcess = spawn2, platform = p
         }
       } catch {
       }
-      resolve4(result);
+      resolve5(result);
     };
     let child;
     try {