@vellumai/assistant 0.8.9-staging.1 → 0.8.9-staging.2

package/src/tools/acp/spawn.test.ts

@@ -15,8 +15,12 @@ const {
   reset: resetExecFileStub,
 } = installExecFileStub();
 
+/** Fixed resolved `bun` path so install script keys are predictable. */
+const BUN_BIN = "/usr/local/bin/bun";
+const BUN_ADD_KEY = `${BUN_BIN} add`;
+
 // Default ACP config used by these tests: the `unknown-agent` entry is here
-// to give the "no version check" test a configured agent whose binary isn't
+// to give the "unmapped binary" tests a configured agent whose command isn't
 // in DEFAULT_AGENT_NPM_PACKAGES.
 const DEFAULT_TEST_AGENTS = {
   claude: { command: "claude-agent-acp", args: [] },
@@ -143,8 +147,7 @@ mock.module("../../acp/index.js", () => ({
   getAcpSessionManager: () => ({ spawn: spawnMock }),
 }));
 
-const { executeAcpSpawn, _resetAdapterVersionCacheForTests } =
-  await import("./spawn.js");
+const { executeAcpSpawn } = await import("./spawn.js");
 const { _resetAdapterInstallCacheForTests } = await import(
   "../../acp/auto-install.js"
 );
@@ -165,9 +168,10 @@ function makeContext(): ToolContext {
 beforeEach(() => {
   resetExecFileStub();
   spawnMock.mockClear();
-  _resetAdapterVersionCacheForTests();
   _resetAdapterInstallCacheForTests();
   config.setConfig({ agents: DEFAULT_TEST_AGENTS });
+  // Default: every command (including bun and the adapters) on PATH, so
+  // spawns resolve directly with no install.
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
   // Default: vault has a claude token so the preflight in `prepareAgentEnv`
   // succeeds for tests that don't care about env injection. Env-injection
@@ -181,135 +185,41 @@ beforeEach(() => {
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("executeAcpSpawn — version check", () => {
-  test("execFile failure: spawn proceeds without warning", async () => {
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
-
+describe("executeAcpSpawn - happy path", () => {
+  test("binary on PATH: spawns directly with no install and no npm probe", async () => {
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
       makeContext(),
     );
 
     expect(result.isError).toBe(false);
+    // No package manager is ever invoked when the binary is already present.
+    expect(execFileMock).not.toHaveBeenCalled();
     expect(result.content).not.toContain("outdated");
-    expect(result.content).not.toContain("Note:");
-    // Spawn was actually invoked.
     expect(spawnMock).toHaveBeenCalledTimes(1);
-    // Sanity: payload shape preserved.
-    const lines = result.content.split("\n\n");
-    const payload = JSON.parse(lines[0]);
+    const payload = JSON.parse(result.content);
     expect(payload.acpSessionId).toBe("acp-session-test");
     expect(payload.status).toBe("running");
+    // The real adapter binary is spawned (no `bun x` wrapper).
+    const agentConfigArg = spawnMock.mock.calls[0][1] as { command: string };
+    expect(agentConfigArg.command).toBe("claude-agent-acp");
   });
 
-  test("outdated version: spawn proceeds AND warning appears in content", async () => {
-    execScripts.set("npm ls", {
-      stdout: JSON.stringify({
-        dependencies: {
-          "@agentclientprotocol/claude-agent-acp": { version: "0.1.0" },
-        },
-      }),
-    });
-    execScripts.set("npm view", { stdout: "0.2.0\n" });
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("outdated");
-    expect(result.content).toContain("@agentclientprotocol/claude-agent-acp");
-    expect(result.content).toContain("0.1.0");
-    expect(result.content).toContain("0.2.0");
-    expect(result.content).toContain(
-      "npm install -g @agentclientprotocol/claude-agent-acp@0.2.0",
-    );
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    // Payload still parses as JSON before the warning suffix.
-    const [payloadJson] = result.content.split("\n\n");
-    const payload = JSON.parse(payloadJson);
-    expect(payload.acpSessionId).toBe("acp-session-test");
-  });
-
-  test("up-to-date version: spawn proceeds, no warning", async () => {
-    execScripts.set("npm ls", {
-      stdout: JSON.stringify({
-        dependencies: {
-          "@agentclientprotocol/claude-agent-acp": { version: "0.2.0" },
-        },
-      }),
-    });
-    execScripts.set("npm view", { stdout: "0.2.0\n" });
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).not.toContain("outdated");
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("unknown command: no version check is performed", async () => {
-    // No execScripts set — if the implementation tried to run npm, the
-    // mock would callback with "No script for ..." and we could detect
-    // the failure. But since the registry doesn't include this command,
-    // the implementation should skip the check entirely without calling
-    // execFile.
-    execFileMock.mockClear();
+  test("default-profile fallback when user config is empty", async () => {
+    // No user `agents.codex` entry, but `agent: "codex"` works via the bundled
+    // default profile (command: "codex-acp"). The resolver merges defaults
+    // automatically.
+    config.setConfig({ agents: {} });
 
     const result = await executeAcpSpawn(
-      { agent: "unknown-agent", task: "do something" },
+      { agent: "codex", task: "do something" },
       makeContext(),
     );
 
     expect(result.isError).toBe(false);
-    expect(execFileMock).not.toHaveBeenCalled();
     expect(spawnMock).toHaveBeenCalledTimes(1);
-    // No outdated note suffix.
-    expect(result.content).not.toContain("outdated");
-  });
-
-  test("cached null result: second call does not reprobe", async () => {
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
-
-    await executeAcpSpawn({ agent: "claude", task: "task 1" }, makeContext());
-    const firstCallCount = execFileMock.mock.calls.length;
-    expect(firstCallCount).toBeGreaterThan(0);
-
-    await executeAcpSpawn({ agent: "claude", task: "task 2" }, makeContext());
-    // No additional execFile calls — result was cached.
-    expect(execFileMock.mock.calls.length).toBe(firstCallCount);
-  });
-
-  test("cached outdated result: second call does not reprobe but still warns", async () => {
-    execScripts.set("npm ls", {
-      stdout: JSON.stringify({
-        dependencies: {
-          "@agentclientprotocol/claude-agent-acp": { version: "0.1.0" },
-        },
-      }),
-    });
-    execScripts.set("npm view", { stdout: "0.2.0\n" });
-
-    const first = await executeAcpSpawn(
-      { agent: "claude", task: "task 1" },
-      makeContext(),
-    );
-    expect(first.content).toContain("outdated");
-    const firstCallCount = execFileMock.mock.calls.length;
-
-    const second = await executeAcpSpawn(
-      { agent: "claude", task: "task 2" },
-      makeContext(),
-    );
-    expect(second.content).toContain("outdated");
-    // No additional execFile calls — outdated info was cached.
-    expect(execFileMock.mock.calls.length).toBe(firstCallCount);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as { command: string };
+    expect(agentConfigArg.command).toBe("codex-acp");
   });
 });
 
@@ -350,9 +260,8 @@ describe("executeAcpSpawn — input validation", () => {
     expect(result.content).toContain("acp.enabled");
   });
 
-  test("missing binary returns install hint when auto-install fails", async () => {
-    which.setWhich({});
-    execScripts.set("npm i", { error: new Error("npm not installed") });
+  test("missing binary + bun absent returns install hint, no install attempted", async () => {
+    which.setWhich({}); // neither bun nor the adapter on PATH
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
       makeContext(),
@@ -360,47 +269,29 @@ describe("executeAcpSpawn — input validation", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("claude-agent-acp is not on PATH");
     expect(result.content).toContain(
-      "npm i -g @agentclientprotocol/claude-agent-acp",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
+    expect(execFileMock).not.toHaveBeenCalled();
     expect(spawnMock).not.toHaveBeenCalled();
   });
-
-  test("default-profile fallback when user config is empty", async () => {
-    // No user `agents.codex` entry, but `agent: "codex"` works via the bundled
-    // default profile (command: "codex-acp"). The resolver merges defaults
-    // automatically.
-    config.setConfig({ agents: {} });
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
-
-    const result = await executeAcpSpawn(
-      { agent: "codex", task: "do something" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    // The agentConfig handed to spawn() should be the bundled default.
-    const agentConfigArg = spawnMock.mock.calls[0][1] as { command: string };
-    expect(agentConfigArg.command).toBe("codex-acp");
-  });
 });
 
-describe("executeAcpSpawn: auto-install on missing binary", () => {
-  test("known command: installs the mapped package and spawn proceeds with a note", async () => {
-    // Binary appears on PATH only after `npm i -g` runs, simulating a
-    // successful global install.
+describe("executeAcpSpawn: sandboxed bun auto-install on missing binary", () => {
+  test("known command + bun present: installs via bun and spawn proceeds with a note", async () => {
+    // Only bun is on PATH until `bun add --global` runs, simulating a
+    // successful global install that links the adapter bin onto PATH.
     let binaryOnPath = false;
-    which.setWhich((cmd) => (binaryOnPath ? `/usr/local/bin/${cmd}` : null));
-    execScripts.set("npm i", {
+    which.setWhich((cmd) => {
+      if (cmd === "bun") return BUN_BIN;
+      if (binaryOnPath) return `/usr/local/bin/${cmd}`;
+      return null;
+    });
+    execScripts.set(BUN_ADD_KEY, {
       stdout: "",
       onCall: () => {
         binaryOnPath = true;
       },
     });
-    // Version probes after the install: best-effort, scripted to skip.
-    execScripts.set("npm ls", { error: new Error("skip") });
-    execScripts.set("npm view", { error: new Error("skip") });
 
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
@@ -409,23 +300,67 @@ describe("executeAcpSpawn: auto-install on missing binary", () => {
 
     expect(result.isError).toBe(false);
     expect(spawnMock).toHaveBeenCalledTimes(1);
-    const [payloadJson] = result.content.split("\n\n");
-    const payload = JSON.parse(payloadJson);
+    const payload = JSON.parse(result.content);
     expect(payload.message).toContain(
       "Installed @agentclientprotocol/claude-agent-acp automatically.",
     );
-    const installCalls = execFileMock.mock.calls.filter(
-      (call) => (call[1] as string[])[0] === "i",
+    // The real binary was spawned with cwd = the project dir and token
+    // injected (trusted-binary config, no resolution at spawn).
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      command: string;
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.command).toBe("claude-agent-acp");
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "default-test-token",
     );
-    expect(installCalls).toHaveLength(1);
-    expect(installCalls[0][1]).toEqual([
-      "i",
-      "-g",
+    expect(spawnMock.mock.calls[0][3]).toBe("/tmp");
+
+    // Exactly one install, and it was `bun add --global` (never npm).
+    expect(execFileMock).toHaveBeenCalledTimes(1);
+    const [command, args] = execFileMock.mock.calls[0];
+    expect(command).toBe(BUN_BIN);
+    expect(args).toEqual([
+      "add",
+      "--global",
       "@agentclientprotocol/claude-agent-acp",
     ]);
   });
 
-  test("unknown command: no install attempted, plain hint returned", async () => {
+  test("the installer cwd is a temp dir (not the project cwd) with secrets stripped", async () => {
+    let binaryOnPath = false;
+    which.setWhich((cmd) => {
+      if (cmd === "bun") return BUN_BIN;
+      if (binaryOnPath) return `/usr/local/bin/${cmd}`;
+      return null;
+    });
+    execScripts.set(BUN_ADD_KEY, {
+      stdout: "",
+      onCall: () => {
+        binaryOnPath = true;
+      },
+    });
+
+    await executeAcpSpawn(
+      { agent: "claude", task: "do something", cwd: "/untrusted/project" },
+      makeContext(),
+    );
+
+    const options = execFileMock.mock.calls[0][2] as {
+      cwd?: string;
+      env?: NodeJS.ProcessEnv;
+    };
+    expect(options.cwd).toBeDefined();
+    expect(options.cwd).not.toBe("/untrusted/project");
+    expect(options.cwd).toContain("vellum-acp-install-");
+    expect(options.env?.CLAUDE_CODE_OAUTH_TOKEN).toBeUndefined();
+    expect(options.env?.GEMINI_API_KEY).toBeUndefined();
+    expect(options.env?.BUN_CONFIG_REGISTRY).toBe(
+      "https://registry.npmjs.org/",
+    );
+  });
+
+  test("unmapped command: no install attempted, plain hint returned", async () => {
     which.setWhich({});
 
     const result = await executeAcpSpawn(
@@ -444,9 +379,9 @@ describe("executeAcpSpawn: auto-install on missing binary", () => {
   test("no client connected: no install attempted even when the binary is missing", async () => {
     // The no-client guard is a pure precondition and must run BEFORE the
     // auto-install side effect: without a client the spawn fails anyway, so
-    // the host must not be mutated by `npm i -g` (which can also block for
-    // up to the install timeout).
-    which.setWhich({});
+    // the host must not be mutated by a global install (which can also block
+    // for up to the install timeout).
+    which.setWhich({ bun: BUN_BIN });
 
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
@@ -459,9 +394,9 @@ describe("executeAcpSpawn: auto-install on missing binary", () => {
     expect(spawnMock).not.toHaveBeenCalled();
   });
 
-  test("npm failure: hint and install failure both surface", async () => {
-    which.setWhich({});
-    execScripts.set("npm i", {
+  test("install failure: hint and install failure both surface, never npm", async () => {
+    which.setWhich({ bun: BUN_BIN }); // bun present, adapter never appears
+    execScripts.set(BUN_ADD_KEY, {
       error: new Error("EACCES: permission denied"),
     });
 
@@ -473,75 +408,26 @@ describe("executeAcpSpawn: auto-install on missing binary", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("claude-agent-acp is not on PATH");
     expect(result.content).toContain(
-      "npm i -g @agentclientprotocol/claude-agent-acp",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
     expect(result.content).toContain("auto-install failed");
     expect(result.content).toContain("EACCES");
+    for (const call of execFileMock.mock.calls) {
+      expect(call[0]).not.toBe("npm");
+    }
     expect(spawnMock).not.toHaveBeenCalled();
   });
 });
 
-describe("executeAcpSpawn - bunx fallback when binary missing", () => {
-  test("binary missing + bun present: spawns via `bun x` with env injection and resume hint, no npm calls", async () => {
-    // Only bun is on PATH - the platform-hosted image (bun, no node/npm).
-    which.setWhich({ bun: "/usr/local/bin/bun" });
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    // No npm install AND no npm version probe: bunx fetches the package on
-    // first use and there is no global install to compare.
-    expect(execFileMock).not.toHaveBeenCalled();
-    expect(result.content).not.toContain("outdated");
-
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    const agentConfigArg = spawnMock.mock.calls[0][1] as {
-      command: string;
-      args: string[];
-      adapterCommand?: string;
-      env?: Record<string, string>;
-    };
-    expect(agentConfigArg.command).toBe("bun");
-    expect(agentConfigArg.args).toEqual([
-      "x",
-      "--bun",
-      "@agentclientprotocol/claude-agent-acp",
-    ]);
-    expect(agentConfigArg.adapterCommand).toBe("claude-agent-acp");
-    // CLAUDE_CODE_OAUTH_TOKEN injection still applies to the bunx-resolved
-    // claude adapter (gated on adapterCommand, not the spawn command).
-    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
-      "default-test-token",
-    );
-
-    const [payloadJson] = result.content.split("\n\n");
-    const payload = JSON.parse(payloadJson);
-    // No auto-install happened; the claude resume hint still fires.
-    expect(payload.message).not.toContain("Installed");
-    expect(payload.message).toContain("claude --resume");
-  });
-
-  // The bun-absent npm fallback is covered by the existing auto-install
-  // suite below ("known command: installs the mapped package..."), whose
-  // which-stub leaves bun off PATH until the install completes.
-});
-
 describe("executeAcpSpawn — per-agent resume hint", () => {
   test("claude payload includes the `claude --resume` hint", async () => {
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
-
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
       makeContext(),
     );
 
     expect(result.isError).toBe(false);
-    const [payloadJson] = result.content.split("\n\n");
-    const payload = JSON.parse(payloadJson);
+    const payload = JSON.parse(result.content);
     expect(payload.message).toContain("claude --resume");
     expect(payload.message).toContain("To resume:");
   });
@@ -549,17 +435,13 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
   test("non-claude payload omits the `claude --resume` hint", async () => {
     // `claude --resume <id>` is Claude Code-specific. Codex (and any other
     // adapter) should not have that command suggested back to the user.
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
-
     const result = await executeAcpSpawn(
       { agent: "codex", task: "do something" },
       makeContext(),
     );
 
     expect(result.isError).toBe(false);
-    const [payloadJson] = result.content.split("\n\n");
-    const payload = JSON.parse(payloadJson);
+    const payload = JSON.parse(result.content);
     expect(payload.message).not.toContain("claude --resume");
     expect(payload.message).not.toContain("To resume:");
   });
@@ -585,8 +467,6 @@ describe("executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN injection", () => {
     vaultStore.clear();
     metadataStore.clear();
     vaultStore.set("acp/claude_oauth_token", "tool-vault-token-abc");
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
 
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
@@ -617,8 +497,6 @@ describe("executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN injection", () => {
         "unknown-agent": { command: "some-other-binary", args: [] },
       },
     });
-    execScripts.set("npm ls", { error: new Error("npm not installed") });
-    execScripts.set("npm view", { error: new Error("npm not installed") });
 
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },

package/src/tools/acp/spawn.ts

@@ -1,108 +1,13 @@
-import {
-  execFileWithTimeout,
-  resolveAgentWithAutoInstall,
-} from "../../acp/auto-install.js";
+import { basename } from "node:path";
+
+import { resolveAgentWithAutoInstall } from "../../acp/auto-install.js";
 import { getAcpSessionManager } from "../../acp/index.js";
 import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
-import {
-  adapterCommandOf,
-  formatResolveFailure,
-  runsViaBunx,
-} from "../../acp/resolve-agent.js";
+import { formatResolveFailure } from "../../acp/resolve-agent.js";
 import { claudeResumeHint } from "../../acp/resume-hint.js";
-import { DEFAULT_AGENT_NPM_PACKAGES } from "../../config/acp-defaults.js";
-import { getLogger } from "../../util/logger.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 import { getSendToClient } from "./context.js";
 
-const log = getLogger("acp:spawn");
-
-/** Per-call timeout for `npm` probes. Best-effort: timeouts are non-fatal. */
-const NPM_PROBE_TIMEOUT_MS = 5_000;
-
-/**
- * Cache of resolved version-check outcomes — including `null` for "skipped" —
- * keyed by command. Lives for the process lifetime so retries don't reprobe.
- */
-const adapterVersionCache = new Map<string, AdapterVersionInfo | null>();
-
-interface AdapterVersionInfo {
-  outdated: true;
-  installed: string;
-  latest: string;
-  packageName: string;
-}
-
-/**
- * Checks if the globally-installed ACP adapter for `command` is outdated.
- * Best-effort: any error or timeout returns `null` (skipped). Unknown
- * commands also return `null`. Results are cached per-command for the
- * process lifetime.
- *
- * Note: `npm ls -g` doesn't see Homebrew/tarball installs, so a "not found"
- * here doesn't mean the binary is missing — it just means we can't compare
- * versions. The caller must NEVER block the spawn on this result.
- */
-async function checkAdapterVersion(
-  command: string,
-): Promise<AdapterVersionInfo | null> {
-  if (adapterVersionCache.has(command)) {
-    return adapterVersionCache.get(command) ?? null;
-  }
-
-  const packageName = DEFAULT_AGENT_NPM_PACKAGES[command];
-  if (!packageName) {
-    adapterVersionCache.set(command, null);
-    return null;
-  }
-
-  try {
-    const [installedRaw, latestRaw] = await Promise.all([
-      execFileWithTimeout(
-        "npm",
-        ["ls", "-g", "--json", packageName],
-        NPM_PROBE_TIMEOUT_MS,
-      ),
-      execFileWithTimeout(
-        "npm",
-        ["view", packageName, "version"],
-        NPM_PROBE_TIMEOUT_MS,
-      ),
-    ]);
-
-    const installed =
-      JSON.parse(installedRaw)?.dependencies?.[packageName]?.version;
-    const latest = latestRaw.trim();
-
-    if (!installed || !latest || installed === latest) {
-      adapterVersionCache.set(command, null);
-      return null;
-    }
-
-    log.info({ installed, latest, packageName }, "ACP adapter is outdated");
-    const info: AdapterVersionInfo = {
-      outdated: true,
-      installed,
-      latest,
-      packageName,
-    };
-    adapterVersionCache.set(command, info);
-    return info;
-  } catch (err) {
-    log.warn(
-      { err, packageName },
-      "Failed to check ACP adapter version (best-effort, skipping)",
-    );
-    adapterVersionCache.set(command, null);
-    return null;
-  }
-}
-
-/** @internal — exposed for tests only. */
-export function _resetAdapterVersionCacheForTests(): void {
-  adapterVersionCache.clear();
-}
-
 export async function executeAcpSpawn(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -115,8 +20,9 @@ export async function executeAcpSpawn(
   }
 
   // Pure precondition: check for a connected client BEFORE any side effects
-  // (auto-install mutates the host via `npm i -g` and can block for up to
-  // the install timeout). Without a client the spawn cannot succeed anyway.
+  // (auto-install mutates the host via a `bun` global install and can block
+  // for up to the install timeout). Without a client the spawn cannot
+  // succeed anyway.
   const sendToClient = getSendToClient(context);
   if (!sendToClient) {
     return {
@@ -150,14 +56,6 @@ export async function executeAcpSpawn(
     return { content: msg, isError: true };
   }
 
-  // Best-effort version check — never blocks the spawn. If outdated, we
-  // append a non-blocking warning to the success payload. Skipped for
-  // bunx-resolved agents: there is no global npm install to compare (bun
-  // fetches the package on first use), and npm may not exist on the host.
-  const versionInfo = runsViaBunx(agentConfig)
-    ? null
-    : await checkAdapterVersion(adapterCommandOf(agentConfig));
-
   try {
     const manager = getAcpSessionManager();
     const cwd = (input.cwd as string) || context.workingDir;
@@ -171,10 +69,10 @@ export async function executeAcpSpawn(
     );
 
     // Claude Code-only resume hint; empty for other adapters. Keyed off the
-    // canonical adapter command so it survives the bunx rewrite. See
+    // resolved command basename (always the real adapter binary). See
     // acp/resume-hint.ts for the gating rationale.
     const hint = claudeResumeHint(
-      adapterCommandOf(agentConfig),
+      basename(agentConfig.command),
       cwd,
       protocolSessionId,
     );
@@ -194,15 +92,7 @@ export async function executeAcpSpawn(
         `${installNote}${resumeHint}`,
     });
 
-    let content = payload;
-    if (versionInfo) {
-      content +=
-        `\n\nNote: ${versionInfo.packageName} is outdated ` +
-        `(installed: ${versionInfo.installed}, latest: ${versionInfo.latest}). ` +
-        `To update, run: npm install -g ${versionInfo.packageName}@${versionInfo.latest}`;
-    }
-
-    return { content, isError: false };
+    return { content: payload, isError: false };
   } catch (err) {
     const msg =
       err instanceof Error