@wrongstack/acp 0.306.4 → 0.307.0

package/dist/wrongstack-acp-agent.js

@@ -7,8 +7,6 @@ import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
 
 // src/agent/protocol-handler.ts
 import { randomUUID } from "node:crypto";
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
 
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
@@ -34,7 +32,9 @@ function toWire(msg) {
 }
 var WRONGSTACK_VERSION = ACP_PACKAGE_VERSION;
 
-// src/agent/protocol-handler.ts
+// src/agent/protocol-session-ops.ts
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
 var WRONGSTACK_AUTH_METHODS = [
   {
     id: "wrongstack-auth",
@@ -53,6 +53,384 @@ var DEFAULT_MODES = [
     description: "Default agent mode for code-generation tasks."
   }
 ];
+async function resolveSessionCwd(requested) {
+  if (!path.isAbsolute(requested)) return null;
+  const resolved = path.resolve(requested);
+  try {
+    const stat2 = await fsp.stat(resolved);
+    return stat2.isDirectory() ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+function errorToJsonRpc(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.code === "number" && typeof e.message === "string") {
+      const result = {
+        code: e.code,
+        message: e.message
+      };
+      if (e.data !== void 0) result.data = e.data;
+      return result;
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return { code: -32603, message };
+}
+function createRunTurnApi(sessionId, clientCapabilities, request) {
+  return {
+    clientCapabilities,
+    requestPermission: async (req) => {
+      const res = await request("session/request_permission", {
+        sessionId,
+        toolCall: req.toolCall,
+        options: req.options
+      });
+      const outcome = res?.outcome;
+      return outcome ?? { outcome: "cancelled" };
+    },
+    readTextFile: async (params) => {
+      const res = await request("fs/read_text_file", { sessionId, ...params });
+      return String(res?.content ?? "");
+    },
+    writeTextFile: async (params) => {
+      await request("fs/write_text_file", { sessionId, ...params });
+    },
+    runTerminal: async ({ command, args, cwd }) => {
+      const created = await request("terminal/create", {
+        sessionId,
+        command,
+        ...args ? { args } : {},
+        ...cwd ? { cwd } : {}
+      });
+      const terminalId = created?.terminalId;
+      if (!terminalId) return { output: "", exitCode: null };
+      try {
+        const exit = await request("terminal/wait_for_exit", {
+          sessionId,
+          terminalId
+        });
+        const out = await request("terminal/output", { sessionId, terminalId });
+        return {
+          output: String(out?.output ?? ""),
+          exitCode: typeof exit?.exitCode === "number" ? exit.exitCode : null
+        };
+      } finally {
+        try {
+          await request("terminal/release", { sessionId, terminalId });
+        } catch {
+        }
+      }
+    }
+  };
+}
+function buildInitializeResult(agentName, modes, configOptions) {
+  return {
+    protocolVersion: ACP_PROTOCOL_VERSION,
+    agentCapabilities: {
+      loadSession: true,
+      promptCapabilities: {
+        image: true,
+        audio: false,
+        embeddedContext: true
+      },
+      mcpCapabilities: {
+        http: false,
+        sse: false
+      },
+      sessionCapabilities: {
+        close: {},
+        list: {},
+        delete: {},
+        resume: {},
+        fork: {}
+      },
+      auth: {
+        logout: {}
+      }
+    },
+    agentInfo: {
+      name: agentName,
+      title: "WrongStack",
+      version: WRONGSTACK_VERSION
+    },
+    authMethods: WRONGSTACK_AUTH_METHODS,
+    modes,
+    configOptions
+  };
+}
+
+// src/agent/protocol-session-management.ts
+async function handleSessionNewOp(ctx, id, params) {
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
+  const p = params ?? {};
+  let cwd = ctx.defaultCwd;
+  if (typeof p.cwd === "string") {
+    const resolved = await resolveSessionCwd(p.cwd);
+    if (resolved === null) {
+      await ctx.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
+      return false;
+    }
+    cwd = resolved;
+  }
+  const sessionId = `sess_${ctx.allocId()}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    id: sessionId,
+    cwd,
+    abort: new AbortController(),
+    modeId: DEFAULT_MODE_ID,
+    createdAt: now,
+    updatedAt: now
+  };
+  ctx.sessions.set(sessionId, state);
+  ctx.onSessionNew(state);
+  await ctx.persist(state);
+  await ctx.sendNotification({
+    sessionId,
+    update: {
+      sessionUpdate: "current_mode_update",
+      modeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID
+    }
+  });
+  if (ctx.configOptions.length > 0) {
+    await ctx.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions: [...ctx.configOptions]
+      }
+    });
+  }
+  await ctx.sendResult(id, {
+    sessionId,
+    modes: ctx.modes,
+    configOptions: ctx.configOptions
+  });
+  return false;
+}
+async function handleSessionLoadOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
+  const existing = sessionId ? ctx.sessions.get(sessionId) : void 0;
+  if (!existing && sessionId && ctx.store) {
+    const persisted = await ctx.store.load(sessionId);
+    if (persisted) {
+      if (ctx.sessions.size >= ctx.maxSessions) {
+        await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+        return false;
+      }
+      if (loadCwd !== void 0 && await resolveSessionCwd(loadCwd) === null) {
+        await ctx.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
+        return false;
+      }
+      const candidateCwd = persisted.cwd ?? loadCwd ?? ctx.defaultCwd;
+      const restoredCwd = await resolveSessionCwd(candidateCwd) ?? ctx.defaultCwd;
+      const restored = {
+        id: sessionId,
+        cwd: restoredCwd,
+        abort: new AbortController(),
+        modeId: persisted.modeId ?? DEFAULT_MODE_ID,
+        createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...persisted.title !== void 0 ? { title: persisted.title } : {}
+      };
+      ctx.sessions.set(sessionId, restored);
+      ctx.seedFor?.(sessionId, persisted.history ?? []);
+      for (const update of persisted.history ?? []) {
+        await ctx.sendNotification({ sessionId, update });
+      }
+      await ctx.sendNotification({
+        sessionId,
+        update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
+      });
+      await ctx.sendResult(id, {
+        initialMode: { currentModeId: restored.modeId, availableModes: ctx.modes }
+      });
+      return false;
+    }
+  }
+  if (existing) {
+    existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const replay = ctx.replayFor?.(sessionId);
+    if (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
+      }
+    });
+    await ctx.sendResult(id, {
+      initialMode: {
+        currentModeId: existing.modeId,
+        availableModes: ctx.modes
+      }
+    });
+    return false;
+  }
+  await ctx.sendError(id, -32e3, `session not found: ${sessionId}`);
+  return false;
+}
+async function handleSessionForkOp(ctx, id, params) {
+  const p = params ?? {};
+  const sourceId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const source = sourceId ? ctx.sessions.get(sourceId) : void 0;
+  if (!sourceId || !source) {
+    await ctx.sendError(id, -32e3, `session not found: ${sourceId}`);
+    return false;
+  }
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
+  let forkCwd = source.cwd;
+  if (typeof p.cwd === "string") {
+    const resolved = await resolveSessionCwd(p.cwd);
+    if (resolved === null) {
+      await ctx.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
+      return false;
+    }
+    forkCwd = resolved;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionId = `sess_${ctx.allocId()}`;
+  const forked = {
+    id: sessionId,
+    cwd: forkCwd,
+    abort: new AbortController(),
+    modeId: source.modeId,
+    createdAt: now,
+    updatedAt: now,
+    ...source.title !== void 0 ? { title: source.title } : {}
+  };
+  const history = (ctx.replayFor?.(sourceId) ?? []).map((update) => ({
+    sessionUpdate: update.sessionUpdate,
+    content: structuredClone(update.content)
+  }));
+  ctx.sessions.set(sessionId, forked);
+  ctx.seedFor?.(sessionId, history);
+  ctx.onSessionNew(forked);
+  await ctx.persist(forked, history);
+  await ctx.sendNotification({
+    sessionId,
+    update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
+  });
+  await ctx.sendResult(id, {
+    sessionId,
+    modes: ctx.modes,
+    configOptions: ctx.configOptions
+  });
+  return false;
+}
+async function handleSessionPromptOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  if (!sessionId || !ctx.sessions.has(sessionId)) {
+    await ctx.sendError(id, -32e3, "unknown or missing sessionId");
+    return false;
+  }
+  if (!Array.isArray(p.prompt)) {
+    await ctx.sendError(id, -32602, "prompt must be an array of content blocks");
+    return false;
+  }
+  const session = ctx.sessions.get(sessionId);
+  if (session.abort.signal.aborted) {
+    session.abort = new AbortController();
+  }
+  const turnSignal = new AbortController();
+  const onCancel = () => turnSignal.abort();
+  session.abort.signal.addEventListener("abort", onCancel, { once: true });
+  const api = createRunTurnApi(
+    sessionId,
+    ctx.clientCapabilities ?? {},
+    (method, req) => ctx.request(method, req)
+  );
+  let result;
+  const pendingNotifications = [];
+  const emit = (update) => {
+    const notifPromise = ctx.sendNotification({ sessionId, update });
+    pendingNotifications.push(notifPromise.catch(() => {
+    }));
+  };
+  try {
+    result = await ctx.runTurn(
+      { sessionId, prompt: p.prompt, signal: turnSignal.signal },
+      emit,
+      api
+    );
+  } catch (err) {
+    session.abort.signal.removeEventListener("abort", onCancel);
+    const { code, message, data } = errorToJsonRpc(err);
+    await ctx.sendError(id, code, message, data);
+    return false;
+  }
+  await Promise.all(pendingNotifications);
+  session.abort.signal.removeEventListener("abort", onCancel);
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.persist(session);
+  await ctx.sendResult(id, { stopReason: result.stopReason });
+  return false;
+}
+async function handleSetModeOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const modeId = typeof p.modeId === "string" ? p.modeId : null;
+  const session = sessionId ? ctx.sessions.get(sessionId) : void 0;
+  if (!session || !modeId || !ctx.modes.some((m) => m.id === modeId)) {
+    await ctx.sendError(id, -32602, "invalid sessionId or modeId");
+    return false;
+  }
+  session.modeId = modeId;
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.sendNotification({
+    sessionId,
+    update: { sessionUpdate: "current_mode_update", modeId }
+  });
+  await ctx.sendResult(id, {});
+  return false;
+}
+async function handleSetConfigOptionOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  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;
+  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.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.sendNotification({
+    sessionId,
+    update: {
+      sessionUpdate: "config_option_update",
+      configOptions: [...ctx.configOptions]
+    }
+  });
+  await ctx.sendResult(id, { configOptions: [...ctx.configOptions] });
+  return false;
+}
+
+// src/agent/protocol-handler.ts
 var ACPProtocolHandler = class {
   transport;
   defaultCwd;
@@ -161,6 +539,27 @@ var ACPProtocolHandler = class {
     } catch {
     }
   }
+  sessionContext() {
+    return {
+      sessions: this.sessions,
+      maxSessions: this.maxSessions,
+      defaultCwd: this.defaultCwd,
+      modes: this.modes,
+      configOptions: this.configOptions,
+      store: this.store,
+      replayFor: this.replayFor,
+      seedFor: this.seedFor,
+      onSessionNew: this.onSessionNew,
+      allocId: () => this.allocId(),
+      persist: (state, history) => this.persist(state, history),
+      sendNotification: (params) => this.sendNotification(params),
+      sendError: (id, code, message, data) => this.sendError(id, code, message, data),
+      sendResult: (id, result) => this.sendResult(id, result),
+      request: (method, params, timeoutMs) => this.request(method, params, timeoutMs),
+      runTurn: this.runTurn,
+      clientCapabilities: this.clientCapabilities
+    };
+  }
   // ────────────────────────────────────────────────────────────────────
   // Requests
   // ────────────────────────────────────────────────────────────────────
@@ -178,9 +577,9 @@ var ACPProtocolHandler = class {
         case "logout":
           return await this.handleLogout(id, params);
         case "session/new":
-          return await this.handleSessionNew(id, params);
+          return await handleSessionNewOp(this.sessionContext(), id, params);
         case "session/load":
-          return await this.handleSessionLoad(id, params);
+          return await handleSessionLoadOp(this.sessionContext(), id, params);
         case "session/resume":
           return await this.handleSessionResume(id, params);
         case "session/close":
@@ -188,15 +587,15 @@ var ACPProtocolHandler = class {
         case "session/delete":
           return await this.handleSessionDelete(id, params);
         case "session/prompt":
-          return await this.handleSessionPrompt(id, params);
+          return await handleSessionPromptOp(this.sessionContext(), id, params);
         case "session/set_mode":
-          return await this.handleSetMode(id, params);
+          return await handleSetModeOp(this.sessionContext(), id, params);
         case "session/set_config_option":
-          return await this.handleSetConfigOption(id, params);
+          return await handleSetConfigOptionOp(this.sessionContext(), id, params);
         case "session/list":
           return await this.handleSessionList(id);
         case "session/fork":
-          return await this.handleSessionFork(id, params);
+          return await handleSessionForkOp(this.sessionContext(), id, params);
         case "providers/list":
           return await this.handleProvidersList(id, params);
         case "providers/set":
@@ -221,232 +620,32 @@ var ACPProtocolHandler = class {
       this.clientCapabilities = p.clientCapabilities;
     }
     this.initialized = true;
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          protocolVersion: ACP_PROTOCOL_VERSION,
-          agentCapabilities: {
-            loadSession: true,
-            promptCapabilities: {
-              // We route ACP image blocks into the core agent's multimodal
-              // input (server-agent-turn.promptToAgentInput); whether the
-              // model can see them is the configured provider's concern.
-              image: true,
-              audio: false,
-              embeddedContext: true
-            },
-            mcpCapabilities: {
-              http: false,
-              sse: false
-            },
-            sessionCapabilities: {
-              close: {},
-              list: {},
-              delete: {},
-              resume: {},
-              fork: {}
-            },
-            auth: {
-              logout: {}
-            }
-          },
-          agentInfo: {
-            name: this.agentName,
-            title: "WrongStack",
-            version: WRONGSTACK_VERSION
-          },
-          authMethods: WRONGSTACK_AUTH_METHODS,
-          modes: this.modes,
-          configOptions: this.configOptions
-        }
-      })
+    await this.sendResult(
+      id,
+      buildInitializeResult(this.agentName, this.modes, this.configOptions)
     );
     return false;
   }
   async handleAuthenticate(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: { outcome: "unauthenticated" }
-      })
-    );
+    await this.sendResult(id, { outcome: "unauthenticated" });
     return false;
   }
   async handleLogout(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {}
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
-  async handleSessionNew(id, params) {
-    if (this.sessions.size >= this.maxSessions) {
-      await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
-      return false;
-    }
-    const p = params ?? {};
-    let cwd = this.defaultCwd;
-    if (typeof p.cwd === "string") {
-      const resolved = await this.resolveSessionCwd(p.cwd);
-      if (resolved === null) {
-        await this.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
-        return false;
-      }
-      cwd = resolved;
-    }
-    const sessionId = `sess_${this.allocId()}`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const state = {
-      id: sessionId,
-      cwd,
-      abort: new AbortController(),
-      modeId: DEFAULT_MODE_ID,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.sessions.set(sessionId, state);
-    this.onSessionNew(state);
-    await this.persist(state);
-    await this.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "current_mode_update",
-        modeId: this.modes[0]?.id ?? DEFAULT_MODE_ID
-      }
-    });
-    if (this.configOptions.length > 0) {
-      await this.sendNotification({
-        sessionId,
-        update: {
-          sessionUpdate: "config_option_update",
-          configOptions: [...this.configOptions]
-        }
-      });
-    }
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          sessionId,
-          modes: this.modes,
-          configOptions: this.configOptions
-        }
-      })
-    );
-    return false;
-  }
-  async handleSessionLoad(id, params) {
+  async handleSessionResume(id, params) {
     const p = params ?? {};
     const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
     const existing = sessionId ? this.sessions.get(sessionId) : void 0;
-    if (!existing && sessionId && this.store) {
-      const persisted = await this.store.load(sessionId);
-      if (persisted) {
-        if (this.sessions.size >= this.maxSessions) {
-          await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
-          return false;
-        }
-        if (loadCwd !== void 0 && await this.resolveSessionCwd(loadCwd) === null) {
-          await this.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
-          return false;
-        }
-        const candidateCwd = persisted.cwd ?? loadCwd ?? this.defaultCwd;
-        const restoredCwd = await this.resolveSessionCwd(candidateCwd) ?? this.defaultCwd;
-        const restored = {
-          id: sessionId,
-          cwd: restoredCwd,
-          abort: new AbortController(),
-          modeId: persisted.modeId ?? DEFAULT_MODE_ID,
-          createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          ...persisted.title !== void 0 ? { title: persisted.title } : {}
-        };
-        this.sessions.set(sessionId, restored);
-        this.seedFor?.(sessionId, persisted.history ?? []);
-        for (const update of persisted.history ?? []) {
-          await this.sendNotification({ sessionId, update });
-        }
-        await this.sendNotification({
-          sessionId,
-          update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
-        });
-        await this.transport.send(
-          toWire({
-            jsonrpc: "2.0",
-            id,
-            result: {
-              initialMode: { currentModeId: restored.modeId, availableModes: this.modes }
-            }
-          })
-        );
-        return false;
-      }
-    }
     if (existing) {
       existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const replay = this.replayFor?.(sessionId);
-      if (replay) {
-        for (const update of replay) {
-          await this.sendNotification({ sessionId, update });
-        }
-      }
-      await this.sendNotification({
-        sessionId,
-        update: {
-          sessionUpdate: "session_info_update",
-          updatedAt: existing.updatedAt
-        }
-      });
-      await this.sendNotification({
-        sessionId,
-        update: {
-          sessionUpdate: "current_mode_update",
-          modeId: existing.modeId
+      await this.sendResult(id, {
+        initialMode: {
+          currentModeId: existing.modeId,
+          availableModes: this.modes
         }
       });
-      await this.transport.send(
-        toWire({
-          jsonrpc: "2.0",
-          id,
-          result: {
-            initialMode: {
-              currentModeId: existing.modeId,
-              availableModes: this.modes
-            }
-          }
-        })
-      );
-      return false;
-    }
-    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
-    return false;
-  }
-  async handleSessionResume(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const existing = sessionId ? this.sessions.get(sessionId) : void 0;
-    if (existing) {
-      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.transport.send(
-        toWire({
-          jsonrpc: "2.0",
-          id,
-          result: {
-            initialMode: {
-              currentModeId: existing.modeId,
-              availableModes: this.modes
-            }
-          }
-        })
-      );
       return false;
     }
     await this.sendError(id, -32e3, `session not found: ${sessionId}`);
@@ -463,13 +662,7 @@ var ACPProtocolHandler = class {
     session.abort.abort();
     this.sessions.delete(sessionId);
     this.disposeSession(sessionId);
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {}
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
   async handleSessionDelete(id, params) {
@@ -480,92 +673,21 @@ var ACPProtocolHandler = class {
       return false;
     }
     if (!this.sessions.has(sessionId)) {
-      await this.transport.send(
-        toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } })
-      );
+      await this.sendResult(id, { configOptions: [...this.configOptions] });
       return false;
     }
     const session = this.sessions.get(sessionId);
     session.abort.abort();
     this.sessions.delete(sessionId);
     this.disposeSession(sessionId);
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {}
-      })
-    );
-    return false;
-  }
-  async handleSessionFork(id, params) {
-    const p = params ?? {};
-    const sourceId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const source = sourceId ? this.sessions.get(sourceId) : void 0;
-    if (!sourceId || !source) {
-      await this.sendError(id, -32e3, `session not found: ${sourceId}`);
-      return false;
-    }
-    if (this.sessions.size >= this.maxSessions) {
-      await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
-      return false;
-    }
-    let forkCwd = source.cwd;
-    if (typeof p.cwd === "string") {
-      const resolved = await this.resolveSessionCwd(p.cwd);
-      if (resolved === null) {
-        await this.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
-        return false;
-      }
-      forkCwd = resolved;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sessionId = `sess_${this.allocId()}`;
-    const forked = {
-      id: sessionId,
-      cwd: forkCwd,
-      abort: new AbortController(),
-      modeId: source.modeId,
-      createdAt: now,
-      updatedAt: now,
-      ...source.title !== void 0 ? { title: source.title } : {}
-    };
-    const history = (this.replayFor?.(sourceId) ?? []).map((update) => ({
-      sessionUpdate: update.sessionUpdate,
-      content: structuredClone(update.content)
-    }));
-    this.sessions.set(sessionId, forked);
-    this.seedFor?.(sessionId, history);
-    this.onSessionNew(forked);
-    await this.persist(forked, history);
-    await this.sendNotification({
-      sessionId,
-      update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
-    });
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          sessionId,
-          modes: this.modes,
-          configOptions: this.configOptions
-        }
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
   async handleProvidersList(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          providers: [],
-          currentProviderId: null
-        }
-      })
-    );
+    await this.sendResult(id, {
+      providers: [],
+      currentProviderId: null
+    });
     return false;
   }
   async handleProvidersSet(id, _params) {
@@ -577,157 +699,13 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleProvidersDisable(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {}
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
   async handleMcpMessage(id, _params) {
     await this.sendError(id, -32e3, "MCP message routing not available through ACP");
     return false;
   }
-  async handleSessionPrompt(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    if (!sessionId || !this.sessions.has(sessionId)) {
-      await this.sendError(id, -32e3, "unknown or missing sessionId");
-      return false;
-    }
-    if (!Array.isArray(p.prompt)) {
-      await this.sendError(id, -32602, "prompt must be an array of content blocks");
-      return false;
-    }
-    const session = this.sessions.get(sessionId);
-    if (session.abort.signal.aborted) {
-      session.abort = new AbortController();
-    }
-    const turnSignal = new AbortController();
-    const onCancel = () => turnSignal.abort();
-    session.abort.signal.addEventListener("abort", onCancel, { once: true });
-    const api = {
-      clientCapabilities: this.clientCapabilities,
-      requestPermission: async (req) => {
-        const res = await this.request("session/request_permission", {
-          sessionId,
-          toolCall: req.toolCall,
-          options: req.options
-        });
-        const outcome = res?.outcome;
-        return outcome ?? { outcome: "cancelled" };
-      },
-      readTextFile: async (params2) => {
-        const res = await this.request("fs/read_text_file", { sessionId, ...params2 });
-        return String(res?.content ?? "");
-      },
-      writeTextFile: async (params2) => {
-        await this.request("fs/write_text_file", { sessionId, ...params2 });
-      },
-      runTerminal: async ({ command, args, cwd }) => {
-        const created = await this.request("terminal/create", {
-          sessionId,
-          command,
-          ...args ? { args } : {},
-          ...cwd ? { cwd } : {}
-        });
-        const terminalId = created?.terminalId;
-        if (!terminalId) return { output: "", exitCode: null };
-        try {
-          const exit = await this.request("terminal/wait_for_exit", {
-            sessionId,
-            terminalId
-          });
-          const out = await this.request("terminal/output", { sessionId, terminalId });
-          return {
-            output: String(out?.output ?? ""),
-            exitCode: typeof exit?.exitCode === "number" ? exit.exitCode : null
-          };
-        } finally {
-          try {
-            await this.request("terminal/release", { sessionId, terminalId });
-          } catch {
-          }
-        }
-      }
-    };
-    let result;
-    const pendingNotifications = [];
-    const emit = (update) => {
-      const p2 = this.sendNotification({ sessionId, update });
-      pendingNotifications.push(p2.catch(() => {
-      }));
-    };
-    try {
-      result = await this.runTurn(
-        { sessionId, prompt: p.prompt, signal: turnSignal.signal },
-        emit,
-        api
-      );
-    } catch (err) {
-      session.abort.signal.removeEventListener("abort", onCancel);
-      const { code, message, data } = errorToJsonRpc(err);
-      await this.sendError(id, code, message, data);
-      return false;
-    }
-    await Promise.all(pendingNotifications);
-    session.abort.signal.removeEventListener("abort", onCancel);
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.persist(session);
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: { stopReason: result.stopReason }
-      })
-    );
-    return false;
-  }
-  async handleSetMode(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const modeId = typeof p.modeId === "string" ? p.modeId : null;
-    const session = sessionId ? this.sessions.get(sessionId) : void 0;
-    if (!session || !modeId || !this.modes.some((m) => m.id === modeId)) {
-      await this.sendError(id, -32602, "invalid sessionId or modeId");
-      return false;
-    }
-    session.modeId = modeId;
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.sendNotification({
-      sessionId,
-      update: { sessionUpdate: "current_mode_update", modeId }
-    });
-    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
-    return false;
-  }
-  async handleSetConfigOption(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const optionId = typeof p.configId === "string" ? p.configId : null;
-    const value = typeof p.value === "string" ? p.value : null;
-    const session = sessionId ? this.sessions.get(sessionId) : void 0;
-    const option = optionId ? this.configOptions.find((o) => o.id === optionId) : void 0;
-    if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
-      await this.sendError(id, -32602, "invalid sessionId, configId, or value");
-      return false;
-    }
-    option.currentValue = value;
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "config_option_update",
-        configOptions: [...this.configOptions]
-      }
-    });
-    await this.transport.send(
-      toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } })
-    );
-    return false;
-  }
   async handleSessionList(id) {
     const sessions = Array.from(this.sessions.values()).map((s) => {
       const out = {
@@ -738,13 +716,7 @@ var ACPProtocolHandler = class {
       if (s.title !== void 0) out.title = s.title;
       return out;
     });
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: { sessions }
-      })
-    );
+    await this.sendResult(id, { sessions });
     return false;
   }
   // ────────────────────────────────────────────────────────────────────
@@ -777,7 +749,9 @@ var ACPProtocolHandler = class {
   async sendNotification(params) {
     await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
   }
-  /** Best-effort durable persistence of a session + its recorded history. */
+  async sendResult(id, result) {
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result }));
+  }
   async persist(state, history = void 0) {
     if (!this.store) return;
     try {
@@ -790,71 +764,10 @@ var ACPProtocolHandler = class {
     if (data !== void 0) error.data = data;
     await this.transport.send(toWire({ jsonrpc: "2.0", id, error }));
   }
-  /**
-   * Allocate a session id (WS-015).
-   *
-   * This was `this.nextId++`, so ids were `sess_1`, `sess_2`, … — and the
-   * handler has no per-connection ownership: any caller that names a session
-   * id can `session/load`, `session/prompt`, `session/cancel` or
-   * `session/delete` it. Over stdio that is academic (one client per process),
-   * but the agent also serves over HTTP, where a guessable id is the whole
-   * authorization story for any local process or page that reaches the port.
-   *
-   * Random ids do not create ownership — they remove the trivial enumeration
-   * that made its absence exploitable. Real per-connection ownership is the
-   * larger fix and is noted in the WS-015 test file.
-   *
-   * The counter is retained: it keeps ids ordered for debugging and guarantees
-   * uniqueness within a process even in the (impossible) event of a UUID
-   * collision. The random half is what makes the id unguessable.
-   */
-  /**
-   * Resolve a client-supplied `cwd` for a session, or `null` when it is not
-   * usable (WS-015).
-   *
-   * `session/new`, `session/load` and `session/fork` all took `params.cwd`
-   * with a single `typeof === 'string'` check and nothing else. That value is
-   * the working directory the agent then reads, writes and executes in.
-   *
-   * SCOPE, deliberately stated: this does NOT confine the session to a root.
-   * In ACP the client IS the editor and legitimately names its own workspace —
-   * Zed and JetBrains pass the project root — so a fixed boundary here would
-   * break the integration this package exists for. What it enforces is that
-   * the directory is absolute and actually exists as a directory: a relative
-   * or missing `cwd` is a bug or an attack under either reading, and silently
-   * running the agent somewhere other than where the client asked is worse
-   * than refusing. Confinement, if wanted, belongs in an operator-set option
-   * on top of this, not in place of it.
-   */
-  async resolveSessionCwd(requested) {
-    if (!path.isAbsolute(requested)) return null;
-    const resolved = path.resolve(requested);
-    try {
-      const stat2 = await fsp.stat(resolved);
-      return stat2.isDirectory() ? resolved : null;
-    } catch {
-      return null;
-    }
-  }
   allocId() {
     return `${this.nextId++}_${randomUUID().replaceAll("-", "")}`;
   }
 };
-function errorToJsonRpc(err) {
-  if (err && typeof err === "object") {
-    const e = err;
-    if (typeof e.code === "number" && typeof e.message === "string") {
-      const result = {
-        code: e.code,
-        message: e.message
-      };
-      if (e.data !== void 0) result.data = e.data;
-      return result;
-    }
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  return { code: -32603, message };
-}
 
 // src/agent/stdio-transport.ts
 import { expectDefined, writeErr } from "@wrongstack/core/utils";