@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/acp/resolve-agent.test.ts

@@ -56,7 +56,9 @@ describe("resolveAcpAgent", () => {
       return;
     }
     expect(result.agent.command).toBe("codex-acp");
-    expect(result.agent.description).toContain("@agentclientprotocol/codex-acp");
+    expect(result.agent.description).toContain(
+      "@agentclientprotocol/codex-acp",
+    );
   });
 
   test("falls back to default profile for claude when no user entry", () => {
@@ -191,7 +193,7 @@ describe("resolveAcpAgent", () => {
       return;
     }
     expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/claude-agent-acp",
+      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
     );
     expect(result.command).toBe("claude-agent-acp");
   });
@@ -240,7 +242,9 @@ describe("resolveAcpAgent", () => {
     if (result.reason !== "binary_not_found") {
       return;
     }
-    expect(result.hint).toBe("bun add -g @agentclientprotocol/codex-acp");
+    expect(result.hint).toBe(
+      "bun add -g @agentclientprotocol/codex-acp@1.10.0",
+    );
   });
 
   test("binary preflight honors agent.env.PATH override (matches spawn env)", () => {
@@ -285,6 +289,178 @@ describe("resolveAcpAgent", () => {
     expect(result.agent.args).toEqual(["--verbose"]);
   });
 
+  test("the bundled claude profile carries its model", () => {
+    config.setConfig({ agents: {} });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.model).toBe("opus");
+  });
+
+  test("a user entry that names a model overrides the bundled one", () => {
+    config.setConfig({
+      agents: {
+        claude: { command: "claude-agent-acp", args: [], model: "sonnet" },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.model).toBe("sonnet");
+  });
+
+  test("a user entry keeping the profile command and omitting model inherits it", () => {
+    config.setConfig({
+      agents: {
+        claude: { command: "claude-agent-acp", args: ["--my-flag"] },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.args).toEqual(["--my-flag"]);
+    expect(result.agent.model).toBe("opus");
+  });
+
+  test("a user entry that omits command entirely still inherits the model", () => {
+    // The schema admits a command-less entry for a bundled id; the profile's
+    // command is inherited with the rest.
+    config.setConfig({
+      agents: {
+        claude: JSON.parse('{"args": ["--my-flag"]}'),
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.command).toBe("claude-agent-acp");
+    expect(result.agent.model).toBe("opus");
+  });
+
+  test("a user entry running the profile adapter by full path still inherits the model", () => {
+    config.setConfig({
+      agents: {
+        claude: { command: "/opt/bin/claude-agent-acp", args: [] },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.command).toBe("/opt/bin/claude-agent-acp");
+    expect(result.agent.model).toBe("opus");
+  });
+
+  test("a user entry pointing the id at another adapter inherits no model", () => {
+    // The bundled aliases are Claude's own vocabulary, so an unrelated
+    // adapter under the `claude` id must not be handed `opus`.
+    config.setConfig({
+      agents: {
+        claude: { command: "my-custom-claude", args: ["--my-flag"] },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.command).toBe("my-custom-claude");
+    expect(result.agent.model).toBeUndefined();
+  });
+
+  test("a user entry naming its own model keeps it across a replaced command", () => {
+    config.setConfig({
+      agents: {
+        claude: {
+          command: "my-custom-claude",
+          args: [],
+          model: "my-fork-large",
+        },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.command).toBe("my-custom-claude");
+    expect(result.agent.model).toBe("my-fork-large");
+  });
+
+  test("a user entry pointing the id at another adapter inherits no description", () => {
+    config.setConfig({
+      agents: {
+        claude: { command: "my-custom-claude", args: [] },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.description).toBeUndefined();
+    const listed = listAcpAgents().agents.find(
+      (entry) => entry.id === "claude",
+    );
+    expect(listed?.command).toBe("my-custom-claude");
+    expect(listed?.description).toBeUndefined();
+  });
+
+  test("a user entry running the profile adapter by full path inherits its description", () => {
+    config.setConfig({
+      agents: {
+        claude: { command: "/opt/bin/claude-agent-acp", args: [] },
+      },
+    });
+
+    const result = resolveAcpAgent("claude");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.description).toContain(
+      "@agentclientprotocol/claude-agent-acp",
+    );
+  });
+
+  test("a bundled profile with no model leaves the resolved agent without one", () => {
+    config.setConfig({ agents: {} });
+
+    const result = resolveAcpAgent("codex");
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.agent.model).toBeUndefined();
+  });
+
   test("resolves a full-path command directly without rewriting it", () => {
     config.setConfig({
       agents: {
@@ -332,7 +508,7 @@ describe("resolveAcpAgent - missing binary", () => {
     }
     expect(result.command).toBe("claude-agent-acp");
     expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/claude-agent-acp",
+      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
     );
   });
 
@@ -351,7 +527,7 @@ describe("resolveAcpAgent - missing binary", () => {
       return;
     }
     expect(result.hint).toBe(
-      "bun add -g @agentclientprotocol/claude-agent-acp",
+      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
     );
   });
 });
@@ -430,7 +606,9 @@ describe("listAcpAgents", () => {
     const codex = result.agents.find((a) => a.id === "codex");
     expect(codex?.available).toBe(false);
     expect(codex?.unavailableReason).toBe("'codex-acp' is not on PATH");
-    expect(codex?.setupHint).toBe("bun add -g @agentclientprotocol/codex-acp");
+    expect(codex?.setupHint).toBe(
+      "bun add -g @agentclientprotocol/codex-acp@1.10.0",
+    );
   });
 
   test("aliases are resolution sugar, not catalog entries", () => {
@@ -489,3 +667,39 @@ describe("listAcpAgents", () => {
     );
   });
 });
+
+describe("agent ids that name Object.prototype members", () => {
+  // An id read off the prototype chain would resolve as a configured agent
+  // that does not exist, and a spawn would start a process for a config
+  // nobody wrote.
+  for (const id of ["__proto__", "constructor", "prototype"]) {
+    test(`"${id}" resolves to nothing`, () => {
+      config.setConfig({ agents: {} });
+
+      const resolved = resolveAcpAgent(id);
+      expect(resolved.ok).toBe(false);
+      if (resolved.ok) {
+        return;
+      }
+      expect(resolved.reason).toBe("unknown_agent");
+      if (resolved.reason !== "unknown_agent") {
+        return;
+      }
+      expect(resolved.available).toEqual(["claude", "codex"]);
+    });
+  }
+
+  test("the catalog never lists one, even when config carries the key", () => {
+    config.setConfig({
+      agents: {
+        ...JSON.parse('{"__proto__": {"command": "evil", "args": []}}'),
+        claude: { command: "claude-agent-acp", args: [] },
+      },
+    });
+
+    expect(listAcpAgents().agents.map((a) => a.id)).toEqual([
+      "claude",
+      "codex",
+    ]);
+  });
+});

package/src/acp/resolve-agent.ts

@@ -1,15 +1,15 @@
 /**
  * Shared resolver for ACP agent ids → agent config + binary preflight.
  *
- * `resolveAcpAgent(id)` merges user-provided `config.acp.agents[id]` (wins on
- * overlap) with the bundled `DEFAULT_ACP_AGENT_PROFILES` so common agents like
- * `claude` and `codex` Just Work with no per-user config required. Natural
- * names ("claude code", "OpenAI Codex") resolve via `AGENT_ID_ALIASES` when the
- * raw id misses both maps. The result is a discriminated union covering every
- * reason a spawn might fail before we even start the agent process: unknown
- * agent id, or binary missing from PATH. Callers (acp_spawn, acp_list_agents,
- * and the `/v1/acp/spawn` HTTP route) get a single source of truth and
- * matching actionable hints.
+ * `resolveAcpAgent(id)` layers user-provided `config.acp.agents[id]` over the
+ * bundled `DEFAULT_ACP_AGENT_PROFILES` so common agents like `claude` and
+ * `codex` Just Work with no per-user config required; `mergeWithProfile` says
+ * what an entry inherits. Natural names ("claude code", "OpenAI Codex")
+ * resolve via `AGENT_ID_ALIASES` when the raw id misses both maps. The result
+ * is a discriminated union covering every reason a spawn might fail before we
+ * even start the agent process: unknown agent id, or binary missing from
+ * PATH. Callers (acp_spawn, acp_list_agents, and the `/v1/acp/spawn` HTTP
+ * route) get a single source of truth and matching actionable hints.
  *
  * The resolver NEVER fetches or runs packages in the (untrusted) task cwd.
  * When the adapter binary is missing, resolution simply fails with
@@ -25,12 +25,16 @@
  * `available` / `setupHint` derived from the same binary resolution.
  */
 
+import { basename } from "node:path";
+
 import {
+  type AcpAgentProfile,
   DEFAULT_ACP_AGENT_PROFILES,
   DEFAULT_AGENT_NPM_PACKAGES,
 } from "../config/acp-defaults.js";
-import type { AcpAgentConfig } from "../config/acp-schema.js";
+import type { AcpAgentConfig as ConfiguredAcpAgent } from "../config/acp-schema.js";
 import { getConfig } from "../config/loader.js";
+import type { AcpAgentConfig } from "./types.js";
 
 /**
  * Whether this agent's entry came from user config (wins over default) or
@@ -134,6 +138,19 @@ const AGENT_ID_ALIASES: Record<string, string> = {
   openaicodex: "codex",
 };
 
+/**
+ * Ids that read back as inherited `Object.prototype` members instead of
+ * configured agents. `directLookup` and `mergedAgentIds` refuse them so an id
+ * from a tool call or an HTTP body can resolve to nothing but a real entry:
+ * resolving one would report a configured agent that does not exist, and a
+ * spawn would then start a process for a config nobody wrote.
+ */
+const PROTOTYPE_SENSITIVE_AGENT_IDS: ReadonlySet<string> = new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+]);
+
 /**
  * Normalize a raw agent id for alias matching: lowercase and strip spaces,
  * underscores, and hyphens so "Claude Code", "claude-code", and
@@ -166,45 +183,92 @@ export function lookupAcpAgentConfig(id: string): AcpAgentConfig | undefined {
 }
 
 function lookupAgent(
-  userAgents: Record<string, AcpAgentConfig>,
+  userAgents: Record<string, ConfiguredAcpAgent>,
   id: string,
-): { agent: AcpAgentConfig; source: AcpAgentSource } | undefined {
+): { agent: AcpAgentConfig; source: AcpAgentSource; id: string } | undefined {
   const direct = directLookup(userAgents, id);
   if (direct) {
-    return direct;
+    return { ...direct, id };
   }
-  const canonicalId = AGENT_ID_ALIASES[normalizeAgentId(id)];
-  return canonicalId !== undefined
-    ? directLookup(userAgents, canonicalId)
+  const normalized = normalizeAgentId(id);
+  const canonicalId = Object.hasOwn(AGENT_ID_ALIASES, normalized)
+    ? AGENT_ID_ALIASES[normalized]
     : undefined;
+  if (canonicalId === undefined) {
+    return undefined;
+  }
+  const aliased = directLookup(userAgents, canonicalId);
+  return aliased ? { ...aliased, id: canonicalId } : undefined;
 }
 
 function directLookup(
-  userAgents: Record<string, AcpAgentConfig>,
+  userAgents: Record<string, ConfiguredAcpAgent>,
   id: string,
 ): { agent: AcpAgentConfig; source: AcpAgentSource } | undefined {
-  const userAgent = userAgents[id];
+  if (PROTOTYPE_SENSITIVE_AGENT_IDS.has(id)) {
+    return undefined;
+  }
+  const userAgent = Object.hasOwn(userAgents, id) ? userAgents[id] : undefined;
+  const defaultAgent = Object.hasOwn(DEFAULT_ACP_AGENT_PROFILES, id)
+    ? DEFAULT_ACP_AGENT_PROFILES[id]
+    : undefined;
   if (userAgent) {
-    return { agent: userAgent, source: "config" };
+    const agent = mergeWithProfile(userAgent, defaultAgent);
+    return agent ? { agent, source: "config" } : undefined;
   }
-  const defaultAgent = DEFAULT_ACP_AGENT_PROFILES[id];
   if (defaultAgent) {
     return { agent: defaultAgent, source: "default" };
   }
   return undefined;
 }
 
+/**
+ * Fill a user config entry from the bundled profile for the same id. An entry
+ * that runs the profile's adapter (it omits `command`, or names the same
+ * binary, by full path or not) inherits the leaves it leaves out: `command`
+ * itself, the description, and the `model` a session starts on. `args` is the
+ * exception, because the schema defaults it to `[]`: a parsed entry always
+ * carries its own, so the profile's never reaches it. An entry that points
+ * the id at a different adapter stands alone, like any user-only entry,
+ * so a config that reuses the `claude` id for something else never carries
+ * Claude's description or has Claude's `opus` sent to it. Zod omits absent
+ * optional keys, so an omission never spreads as an undefined override.
+ *
+ * `undefined` only for an entry with neither a command nor a profile to take
+ * one from, a shape the config schema rejects before it gets here.
+ */
+function mergeWithProfile(
+  userAgent: ConfiguredAcpAgent,
+  profile: AcpAgentProfile | undefined,
+): AcpAgentConfig | undefined {
+  const command = userAgent.command;
+  if (!profile) {
+    return command === undefined ? undefined : { ...userAgent, command };
+  }
+  // A full path to the bundled binary is still the bundled adapter; the
+  // basename is the adapter's identity everywhere else in this module.
+  if (
+    command !== undefined &&
+    basename(command) !== basename(profile.command)
+  ) {
+    return { ...userAgent, command };
+  }
+  return { ...profile, ...userAgent, command: command ?? profile.command };
+}
+
 /**
  * Defaults first (declaration order), then user-only ids. Deduplicated so a
  * user config that overrides a default doesn't list the id twice.
  */
-function mergedAgentIds(userAgents: Record<string, AcpAgentConfig>): string[] {
+function mergedAgentIds(
+  userAgents: Record<string, ConfiguredAcpAgent>,
+): string[] {
   return Array.from(
     new Set([
       ...Object.keys(DEFAULT_ACP_AGENT_PROFILES),
       ...Object.keys(userAgents),
     ]),
-  );
+  ).filter((id) => !PROTOTYPE_SENSITIVE_AGENT_IDS.has(id));
 }
 
 /**
@@ -256,7 +320,8 @@ export function listAcpAgents(): {
   const config = getConfig();
   const userAgents = config.acp.agents;
   const agents: AcpAgentEntry[] = mergedAgentIds(userAgents).map((id) => {
-    // Non-null: ids come from `mergedAgentIds` so the lookup always resolves.
+    // Non-null: ids come from `mergedAgentIds`, and the schema admits a
+    // command-less entry only for a bundled id, so the lookup always resolves.
     const { agent, source } = lookupAgent(userAgents, id)!;
     // Same binary preflight as `resolveAcpAgent`: available iff the command
     // is on PATH. A missing binary is auto-installed at spawn time, but the

package/src/acp/session-manager.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
+import { RequestError } from "@agentclientprotocol/sdk";
+
 import type { Conversation } from "../daemon/conversation.js";
 import {
   deleteConversation,
@@ -39,6 +41,7 @@ mock.module("./prepare-agent-env.js", () => ({
 }));
 
 import { createAbortReason } from "../util/abort-reasons.js";
+import { modelOption } from "./__tests__/helpers/acp-model-option.js";
 import { VellumAcpClientHandler } from "./client-handler.js";
 import { AcpSessionManager } from "./session-manager.js";
 
@@ -90,10 +93,10 @@ function mockConversation(opts?: { enqueueQueued?: boolean }) {
 }
 
 /** Fake AcpAgentProcess covering only the calls firePromptInBackground makes. */
-function fakeProcess(prompt: () => Promise<unknown>) {
+function fakeProcess(prompt: () => Promise<unknown>, stderr = "") {
   return {
     markStderr: () => 0,
-    stderrSince: () => "",
+    stderrSince: () => stderr,
     prompt,
     kill: mock(() => {}),
   };
@@ -365,6 +368,8 @@ describe("AcpSessionManager auth-required recovery surface", () => {
     parentToolUseId?: string;
     cancelled?: boolean;
     credentialDigest?: string;
+    failure?: () => Promise<never>;
+    stderr?: string;
   }) {
     const manager = new AcpSessionManager(1);
     const parentId = `parent-${opts.id}`;
@@ -376,7 +381,7 @@ describe("AcpSessionManager auth-required recovery surface", () => {
       manager,
       opts.id,
       parentId,
-      fakeProcess(authFailure),
+      fakeProcess(opts.failure ?? authFailure, opts.stderr),
     );
     entry.command = opts.command;
     (entry as { parentToolUseId?: string }).parentToolUseId =
@@ -512,6 +517,62 @@ describe("AcpSessionManager auth-required recovery surface", () => {
     expect(r.persistedContent).toBeUndefined();
   });
 
+  test("claude's prompt-time 401 raises the surface when stderr names another failure", async () => {
+    // claude-agent-acp raises it as RequestError.internalError({ errorKind },
+    // cliText), and stderr supplies the failure message, so the auth text
+    // survives only on the rejection's own message.
+    refusedDigests.length = 0;
+    const digest = claudeTokenDigest("sk-ant-oat-prompt-401");
+    const r = await driveAuthFailure({
+      id: "sess-auth-prompt-401",
+      command: "claude-agent-acp",
+      parentToolUseId: "tool-anchor-prompt-401",
+      credentialDigest: digest,
+      failure: () =>
+        Promise.reject(
+          new RequestError(
+            -32603,
+            "Internal error: Failed to authenticate. API Error: 401 OAuth access token has expired.",
+            { errorKind: "authentication_failed" },
+          ),
+        ),
+      stderr: '{"error":{"message":"Something else happened"}}',
+    });
+
+    expect(r.authEvent).toMatchObject({
+      acpSessionId: "sess-auth-prompt-401",
+      authCode: "acp_claude_auth_required",
+      parentToolUseId: "tool-anchor-prompt-401",
+    });
+    expect(hasAcpConnectCardRaised(r.parentId)).toBe(true);
+    expect(refusedDigests).toContain(digest);
+  });
+
+  test("the rejection's own message is checked when its payload names a different reason", async () => {
+    refusedDigests.length = 0;
+    const digest = claudeTokenDigest("sk-ant-oat-own-message");
+    const r = await driveAuthFailure({
+      id: "sess-auth-own-message",
+      command: "claude-agent-acp",
+      parentToolUseId: "tool-anchor-own-message",
+      credentialDigest: digest,
+      failure: () =>
+        Promise.reject(
+          new RequestError(
+            -32603,
+            "Internal error: Failed to authenticate. API Error: 401",
+            { details: "Request failed" },
+          ),
+        ),
+      stderr: '{"error":{"message":"Something else happened"}}',
+    });
+
+    expect(r.authEvent).toMatchObject({
+      authCode: "acp_claude_auth_required",
+    });
+    expect(refusedDigests).toContain(digest);
+  });
+
   test("a non-claude adapter never raises the surface, even on an auth-shaped failure", async () => {
     const r = await driveAuthFailure({
       id: "sess-auth-codex",
@@ -716,4 +777,136 @@ describe("AcpSessionManager.spawn: a stopped turn leaves no agent running", () =
     expect(proc.kill).toHaveBeenCalled();
     expect(internals.sessions.size).toBe(0);
   });
+
+  /**
+   * The model pin is an await of its own, and it sits after the setup
+   * recheck. A stop landing inside it gets the same treatment: no spawned
+   * event, no model event, no prompt, and no session left behind.
+   */
+  test("a cancel during the model pin tears the process down and fires nothing", async () => {
+    const manager = new AcpSessionManager(1);
+    const controller = new AbortController();
+    const prompt = mock(() => Promise.resolve({}));
+    const setConfigOption = mock(async () => {
+      // The user stops the turn while the pin's round trip is open.
+      controller.abort(REASON);
+      return [modelOption("opus")];
+    });
+    const proc = {
+      ...fakeProcess(prompt),
+      spawn: () => {},
+      initialize: async () => {},
+      createSession: async () => ({
+        sessionId: "proto-1",
+        configOptions: [modelOption("sonnet")],
+      }),
+      setConfigOption,
+    };
+    let injected: ReturnType<typeof injectSession> | undefined;
+    const internals = manager as unknown as {
+      registerSession: (opts: {
+        acpSessionId: string;
+        parentConversationId: string;
+      }) => unknown;
+      sessions: Map<string, unknown>;
+    };
+    internals.registerSession = (opts) => {
+      injected = injectSession(
+        manager,
+        opts.acpSessionId,
+        opts.parentConversationId,
+        proc as unknown as ReturnType<typeof fakeProcess>,
+      );
+      return injected;
+    };
+
+    await expect(
+      manager.spawn(
+        "claude",
+        { command: "noop", args: [] } as never,
+        "do the task",
+        "/tmp",
+        "conv-1",
+        () => {},
+        { model: "opus" },
+        { signal: controller.signal },
+      ),
+    ).rejects.toThrow();
+
+    expect(setConfigOption).toHaveBeenCalled();
+    expect(injected?.sendToVellum).not.toHaveBeenCalled();
+    expect(prompt).not.toHaveBeenCalled();
+    expect(proc.kill).toHaveBeenCalled();
+    expect(internals.sessions.size).toBe(0);
+  });
+
+  /**
+   * A cancel that persists a resumable row frees the id, so a resume can
+   * register a fresh entry under it before the stopped spawn's pin settles.
+   * The teardown owes that spawn its own process, and owes the replacement
+   * its map slot.
+   */
+  test("a cancel during the model pin leaves a replacement session for the same id alone", async () => {
+    const manager = new AcpSessionManager(2);
+    const controller = new AbortController();
+    const prompt = mock(() => Promise.resolve({}));
+    let replacement: ReturnType<typeof injectSession> | undefined;
+    let spawnedId: string | undefined;
+    const setConfigOption = mock(async () => {
+      // The turn is stopped and the id is resumed by another request while
+      // the pin's round trip is still open.
+      controller.abort(REASON);
+      replacement = injectSession(
+        manager,
+        spawnedId!,
+        "conv-2",
+        fakeProcess(mock(() => Promise.resolve({}))),
+      );
+      return [modelOption("opus")];
+    });
+    const proc = {
+      ...fakeProcess(prompt),
+      spawn: () => {},
+      initialize: async () => {},
+      createSession: async () => ({
+        sessionId: "proto-1",
+        configOptions: [modelOption("sonnet")],
+      }),
+      setConfigOption,
+    };
+    const internals = manager as unknown as {
+      registerSession: (opts: {
+        acpSessionId: string;
+        parentConversationId: string;
+      }) => unknown;
+      sessions: Map<string, unknown>;
+    };
+    internals.registerSession = (opts) => {
+      spawnedId = opts.acpSessionId;
+      return injectSession(
+        manager,
+        opts.acpSessionId,
+        opts.parentConversationId,
+        proc as unknown as ReturnType<typeof fakeProcess>,
+      );
+    };
+
+    await expect(
+      manager.spawn(
+        "claude",
+        { command: "noop", args: [] } as never,
+        "do the task",
+        "/tmp",
+        "conv-1",
+        () => {},
+        { model: "opus" },
+        { signal: controller.signal },
+      ),
+    ).rejects.toThrow();
+
+    expect(prompt).not.toHaveBeenCalled();
+    expect(proc.kill).toHaveBeenCalled();
+    expect(replacement?.process.kill).not.toHaveBeenCalled();
+    expect(internals.sessions.get(spawnedId!)).toBe(replacement);
+  });
 });