@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

package/src/subagent/manager.ts

@@ -13,11 +13,7 @@ import { v4 as uuid } from "uuid";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { Conversation } from "../daemon/conversation.js";
-import {
-  findConversation,
-  removeSubagentConversation,
-  setSubagentConversation,
-} from "../daemon/conversation-registry.js";
+import { findConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
@@ -338,10 +334,6 @@ export class SubagentManager {
 
     managed.conversation = conversation;
     this.subagents.set(subagentId, managed);
-    // Index the live conversation so the per-conversation injectors (workspace
-    // context, disk-pressure warning) can resolve it by id; subagents are not
-    // in the eviction-managed conversation store.
-    setSubagentConversation(conversationRecord.id, conversation);
     const labelKey = `${config.parentConversationId}:${config.label.toLowerCase().trim()}`;
     if (this.labelIndex.has(labelKey)) {
       log.warn(
@@ -703,9 +695,7 @@ export class SubagentManager {
    */
   private releaseConversation(managed: ManagedSubagent): void {
     if (!managed.conversation) return;
-    const conversation = managed.conversation;
-    removeSubagentConversation(conversation.conversationId, conversation);
-    conversation.dispose();
+    managed.conversation.dispose();
     managed.conversation = null;
     managed.retainedUntil = Date.now() + TERMINAL_RETENTION_MS;
     this.ensureSweepRunning();
@@ -726,18 +716,16 @@ export class SubagentManager {
     if (!managed) return;
 
     if (managed.conversation) {
-      const conversation = managed.conversation;
       if (!TERMINAL_STATUSES.has(managed.state.status)) {
-        conversation.abort(
+        managed.conversation.abort(
           createAbortReason(
             "subagent_aborted",
             "SubagentManager.dispose",
-            conversation.conversationId,
+            managed.conversation.conversationId,
           ),
         );
       }
-      removeSubagentConversation(conversation.conversationId, conversation);
-      conversation.dispose();
+      managed.conversation.dispose();
       managed.conversation = null;
     }
     this.subagents.delete(subagentId);

package/src/tools/acp/list-agents.test.ts

@@ -47,7 +47,7 @@ describe("executeAcpListAgents", () => {
     expect(parsed.hint).toContain("config.json");
   });
 
-  test("enabled, no user config: all defaults present with source 'default' and available based on Bun.which", async () => {
+  test("enabled, no user config: both defaults present with source 'default' and available based on Bun.which", async () => {
     config.setConfig({ agents: {} });
 
     const result = await executeAcpListAgents({}, makeContext());
@@ -58,7 +58,6 @@ describe("executeAcpListAgents", () => {
     expect(parsed.agents.map((a: { id: string }) => a.id)).toEqual([
       "claude",
       "codex",
-      "gemini",
     ]);
     for (const entry of parsed.agents) {
       expect(entry.source).toBe("default");
@@ -109,11 +108,6 @@ describe("executeAcpListAgents", () => {
     expect(codex.unavailableReason).toBe("'codex-acp' is not on PATH");
     expect(codex.setupHint).toBe("npm i -g @zed-industries/codex-acp");
 
-    const gemini = parsed.agents.find((a: { id: string }) => a.id === "gemini");
-    expect(gemini.available).toBe(false);
-    expect(gemini.unavailableReason).toBe("'gemini' is not on PATH");
-    expect(gemini.setupHint).toBe("npm i -g @google/gemini-cli");
-
     const claude = parsed.agents.find((a: { id: string }) => a.id === "claude");
     expect(claude.available).toBe(true);
     expect(claude.setupHint).toBeUndefined();

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

@@ -1,7 +1,7 @@
+import * as realChildProcess from "node:child_process";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { installAcpConfigStub } from "../../acp/__tests__/helpers/acp-config-stub.js";
-import { installExecFileStub } from "../../acp/__tests__/helpers/exec-file-stub.js";
 import { installWhichStub } from "../../acp/__tests__/helpers/which-stub.js";
 import type { ToolContext } from "../types.js";
 
@@ -9,11 +9,55 @@ import type { ToolContext } from "../types.js";
 // Mock infrastructure
 // ---------------------------------------------------------------------------
 
-const {
-  execScripts,
-  execFileMock,
-  reset: resetExecFileStub,
-} = installExecFileStub();
+type ExecCallback = (
+  err: Error | null,
+  stdout: string | Buffer,
+  stderr: string | Buffer,
+) => void;
+
+interface ExecScript {
+  /** When set, the call rejects with this error. */
+  error?: Error;
+  /** When set, the call resolves with this stdout. */
+  stdout?: string;
+}
+
+/**
+ * Per-call scripted responses for `execFile`. Keyed by `${command} ${args[0]}`
+ * so tests can target `npm ls` and `npm view` independently.
+ */
+const execScripts: Map<string, ExecScript> = new Map();
+
+const execFileMock = mock(
+  (
+    command: string,
+    args: string[],
+    _options: unknown,
+    callback?: ExecCallback,
+  ) => {
+    const key = `${command} ${args[0]}`;
+    const script = execScripts.get(key);
+    queueMicrotask(() => {
+      if (!callback) return;
+      if (!script) {
+        callback(new Error(`No script for ${key}`), "", "");
+        return;
+      }
+      if (script.error) {
+        callback(script.error, "", "");
+        return;
+      }
+      callback(null, script.stdout ?? "", "");
+    });
+    // Return value is not used by execFileWithTimeout.
+    return {} as ReturnType<typeof realChildProcess.execFile>;
+  },
+);
+
+mock.module("node:child_process", () => ({
+  ...realChildProcess,
+  execFile: execFileMock,
+}));
 
 // 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
@@ -145,9 +189,6 @@ mock.module("../../acp/index.js", () => ({
 
 const { executeAcpSpawn, _resetAdapterVersionCacheForTests } =
   await import("./spawn.js");
-const { _resetAdapterInstallCacheForTests } = await import(
-  "../../acp/auto-install.js"
-);
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -163,10 +204,10 @@ function makeContext(): ToolContext {
 }
 
 beforeEach(() => {
-  resetExecFileStub();
+  execScripts.clear();
+  execFileMock.mockClear();
   spawnMock.mockClear();
   _resetAdapterVersionCacheForTests();
-  _resetAdapterInstallCacheForTests();
   config.setConfig({ agents: DEFAULT_TEST_AGENTS });
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
   // Default: vault has a claude token so the preflight in `prepareAgentEnv`
@@ -350,9 +391,8 @@ describe("executeAcpSpawn — input validation", () => {
     expect(result.content).toContain("acp.enabled");
   });
 
-  test("missing binary returns install hint when auto-install fails", async () => {
+  test("missing binary returns install hint", async () => {
     which.setWhich({});
-    execScripts.set("npm i", { error: new Error("npm not installed") });
     const result = await executeAcpSpawn(
       { agent: "claude", task: "do something" },
       makeContext(),
@@ -386,149 +426,6 @@ describe("executeAcpSpawn — input validation", () => {
   });
 });
 
-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.
-    let binaryOnPath = false;
-    which.setWhich((cmd) => (binaryOnPath ? `/usr/local/bin/${cmd}` : null));
-    execScripts.set("npm i", {
-      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" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    const [payloadJson] = result.content.split("\n\n");
-    const payload = JSON.parse(payloadJson);
-    expect(payload.message).toContain(
-      "Installed @agentclientprotocol/claude-agent-acp automatically.",
-    );
-    const installCalls = execFileMock.mock.calls.filter(
-      (call) => (call[1] as string[])[0] === "i",
-    );
-    expect(installCalls).toHaveLength(1);
-    expect(installCalls[0][1]).toEqual([
-      "i",
-      "-g",
-      "@agentclientprotocol/claude-agent-acp",
-    ]);
-  });
-
-  test("unknown command: no install attempted, plain hint returned", async () => {
-    which.setWhich({});
-
-    const result = await executeAcpSpawn(
-      { agent: "unknown-agent", task: "do something" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("some-other-binary is not on PATH");
-    expect(result.content).toContain("Install 'some-other-binary'");
-    expect(result.content).not.toContain("auto-install failed");
-    expect(execFileMock).not.toHaveBeenCalled();
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
-  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({});
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something" },
-      { ...makeContext(), sendToClient: undefined },
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("No client connected");
-    expect(execFileMock).not.toHaveBeenCalled();
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
-  test("npm failure: hint and install failure both surface", async () => {
-    which.setWhich({});
-    execScripts.set("npm i", {
-      error: new Error("EACCES: permission denied"),
-    });
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something" },
-      makeContext(),
-    );
-
-    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",
-    );
-    expect(result.content).toContain("auto-install failed");
-    expect(result.content).toContain("EACCES");
-    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") });
@@ -543,7 +440,7 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
     const [payloadJson] = result.content.split("\n\n");
     const payload = JSON.parse(payloadJson);
     expect(payload.message).toContain("claude --resume");
-    expect(payload.message).toContain("To resume:");
+    expect(payload.message).toContain("To resume this session later");
   });
 
   test("non-claude payload omits the `claude --resume` hint", async () => {
@@ -561,7 +458,7 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
     const [payloadJson] = result.content.split("\n\n");
     const payload = JSON.parse(payloadJson);
     expect(payload.message).not.toContain("claude --resume");
-    expect(payload.message).not.toContain("To resume:");
+    expect(payload.message).not.toContain("To resume this session later");
   });
 });
 

package/src/tools/acp/spawn.ts

@@ -1,19 +1,11 @@
-import {
-  execFileWithTimeout,
-  resolveAgentWithAutoInstall,
-} from "../../acp/auto-install.js";
+import { execFile } from "node:child_process";
+
 import { getAcpSessionManager } from "../../acp/index.js";
 import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
-import {
-  adapterCommandOf,
-  formatResolveFailure,
-  runsViaBunx,
-} from "../../acp/resolve-agent.js";
-import { claudeResumeHint } from "../../acp/resume-hint.js";
+import { resolveAcpAgent } from "../../acp/resolve-agent.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");
 
@@ -33,6 +25,35 @@ interface AdapterVersionInfo {
   packageName: string;
 }
 
+/**
+ * Run `execFile` with an AbortController-driven timeout. Returns the stdout
+ * on success; throws on error or timeout. Caller treats any throw as a
+ * best-effort skip.
+ */
+function execFileWithTimeout(
+  command: string,
+  args: string[],
+  timeoutMs: number,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    execFile(
+      command,
+      args,
+      { signal: controller.signal, encoding: "utf8" },
+      (err, stdout) => {
+        clearTimeout(timer);
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(stdout);
+      },
+    );
+  });
+}
+
 /**
  * Checks if the globally-installed ACP adapter for `command` is outdated.
  * Best-effort: any error or timeout returns `null` (skipped). Unknown
@@ -114,10 +135,34 @@ export async function executeAcpSpawn(
     return { content: '"task" is required.', isError: true };
   }
 
-  // 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.
-  const sendToClient = getSendToClient(context);
+  const resolved = resolveAcpAgent(agent);
+  if (!resolved.ok) {
+    switch (resolved.reason) {
+      case "acp_disabled":
+        return { content: resolved.hint, isError: true };
+      case "unknown_agent":
+        return {
+          content: `Unknown agent "${agent}". Available: ${resolved.available.join(
+            ", ",
+          )}.`,
+          isError: true,
+        };
+      case "binary_not_found":
+        return {
+          content: `${resolved.command} is not on PATH. ${resolved.hint}`,
+          isError: true,
+        };
+      default: {
+        const _exhaustive: never = resolved;
+        throw new Error(
+          `Unexpected acp resolver reason: ${(_exhaustive as { reason: string }).reason}`,
+        );
+      }
+    }
+  }
+  const sendToClient = context.sendToClient as
+    | ((msg: { type: string; [key: string]: unknown }) => void)
+    | undefined;
   if (!sendToClient) {
     return {
       content: "No client connected - cannot spawn ACP agent.",
@@ -125,17 +170,6 @@ export async function executeAcpSpawn(
     };
   }
 
-  // Resolve the agent, silently auto-installing a missing allowlisted
-  // adapter binary (see acp/auto-install.ts). Shared with the HTTP route.
-  const { resolved, autoInstalledPackage, failureMessage } =
-    await resolveAgentWithAutoInstall(agent);
-  if (failureMessage) {
-    return { content: failureMessage, isError: true };
-  }
-  if (!resolved.ok) {
-    return { content: formatResolveFailure(agent, resolved), isError: true };
-  }
-
   // Inject required env vars and preflight via the shared helper. Mirrors
   // the HTTP route at `runtime/routes/acp-routes.ts:spawnSession` — both
   // call sites MUST go through `prepareAgentEnv` before `manager.spawn`,
@@ -151,12 +185,8 @@ export async function executeAcpSpawn(
   }
 
   // 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));
+  // append a non-blocking warning to the success payload.
+  const versionInfo = await checkAdapterVersion(agentConfig.command);
 
   try {
     const manager = getAcpSessionManager();
@@ -167,21 +197,17 @@ export async function executeAcpSpawn(
       task,
       cwd,
       context.conversationId,
-      sendToClient,
+      sendToClient as (msg: unknown) => void,
     );
 
-    // Claude Code-only resume hint; empty for other adapters. Keyed off the
-    // canonical adapter command so it survives the bunx rewrite. See
-    // acp/resume-hint.ts for the gating rationale.
-    const hint = claudeResumeHint(
-      adapterCommandOf(agentConfig),
-      cwd,
-      protocolSessionId,
-    );
-    const resumeHint = hint ? ` ${hint}` : "";
-    const installNote = autoInstalledPackage
-      ? ` Installed ${autoInstalledPackage} automatically.`
-      : "";
+    // `claude --resume <id>` is Claude Code-specific (the claude-agent-acp
+    // adapter binary). Other adapters resume differently or not at all,
+    // so the hint is gated by the resolved binary, not the agent id —
+    // this stays correct when a user aliases an id to a different binary.
+    const resumeHint =
+      agentConfig.command === "claude-agent-acp"
+        ? ` To resume this session later, run: cd ${cwd} && claude --resume ${protocolSessionId}`
+        : "";
     const payload = JSON.stringify({
       acpSessionId,
       protocolSessionId,
@@ -190,8 +216,7 @@ export async function executeAcpSpawn(
       status: "running",
       message:
         `ACP agent "${agent}" spawned (session: ${protocolSessionId}). ` +
-        `Results stream back via SSE. You will be notified when it completes.` +
-        `${installNote}${resumeHint}`,
+        `Results stream back via SSE. You will be notified when it completes.${resumeHint}`,
     });
 
     let content = payload;