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

package/src/runtime/routes/__tests__/acp-routes.test.ts

@@ -1,23 +1,13 @@
 /**
- * Tests for ACP route handlers.
+ * Tests for `GET /v1/acp/sessions`.
  *
- * `GET /v1/acp/sessions`: the handler merges in-memory
- * `AcpSessionManager.getStatus()` output with persisted
- * `acp_session_history` rows, deduping by id (in-memory wins), filtering by
- * `?conversationId`, sorting newest-first, and truncating to `?limit`
- * (default 50, max 500).
- *
- * `POST /v1/acp/spawn`: when the adapter binary is missing, the handler
- * silently auto-installs allowlisted adapter packages before failing with
- * the install hint. `execFile` is stubbed via the shared
- * `installExecFileStub` helper so tests can script `npm i -g` outcomes.
+ * The handler merges in-memory `AcpSessionManager.getStatus()` output with
+ * persisted `acp_session_history` rows, deduping by id (in-memory wins),
+ * filtering by `?conversationId`, sorting newest-first, and truncating to
+ * `?limit` (default 50, max 500).
  */
 
-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 { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../../../util/logger.js", () => ({
   getLogger: () =>
@@ -26,12 +16,6 @@ mock.module("../../../util/logger.js", () => ({
     }),
 }));
 
-const {
-  execScripts,
-  execFileMock,
-  reset: resetExecFileStub,
-} = installExecFileStub();
-
 // ---------------------------------------------------------------------------
 // Stub the ACP session manager so tests control the in-memory side without
 // spawning real child processes. The route handler imports
@@ -53,61 +37,64 @@ interface FakeSessionState {
 
 let fakeInMemorySessions: FakeSessionState[] = [];
 
-const spawnMock = mock(async () => ({
-  acpSessionId: "acp-route-session",
-  protocolSessionId: "proto-route-session",
-}));
-
-const defaultSteerOrResumeImpl = async (
-  _id: string,
-  _instruction: string,
-): Promise<{ resumed: boolean }> => ({ resumed: false });
-let steerOrResumeImpl: (
-  id: string,
-  instruction: string,
-) => Promise<{ resumed: boolean }> = defaultSteerOrResumeImpl;
-const steerOrResumeMock = mock(
-  (id: string, instruction: string, _send: unknown) =>
-    steerOrResumeImpl(id, instruction),
-);
-
 mock.module("../../../acp/index.js", () => ({
   getAcpSessionManager: () => ({
     getStatus: () => fakeInMemorySessions,
-    spawn: spawnMock,
-    steerOrResume: steerOrResumeMock,
   }),
 }));
 
-// Identity env-prep: the credential-broker plumbing it wraps is exercised in
-// its own suite; spawn tests here only care about the resolve/install flow.
-mock.module("../../../acp/prepare-agent-env.js", () => ({
-  prepareAgentEnv: async (agentConfig: unknown) => agentConfig,
-}));
-
-const config = await installAcpConfigStub();
-const which = installWhichStub();
-
-import {
-  clearHistory,
-  insertHistoryRow,
-} from "../../../acp/__tests__/helpers/acp-history-db.js";
-import {
-  AcpResumeError,
-  AcpSessionNotFoundError,
-} from "../../../acp/session-manager.js";
+import { getSqlite } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
-import { FailedDependencyError, NotFoundError } from "../errors.js";
-
-const { ROUTES } = await import("../acp-routes.js");
-const { _resetAdapterInstallCacheForTests } =
-  await import("../../../acp/auto-install.js");
+import { ROUTES } from "../acp-routes.js";
 
 initializeDb();
 
-afterAll(() => {
-  which.restore();
-});
+function clearHistory(): void {
+  getSqlite().run("DELETE FROM acp_session_history");
+}
+
+function insertHistoryRow(row: {
+  id: string;
+  agentId: string;
+  acpSessionId: string;
+  parentConversationId: string;
+  startedAt: number;
+  completedAt?: number | null;
+  status: string;
+  stopReason?: string | null;
+  error?: string | null;
+  eventLogJson?: string;
+}): void {
+  getSqlite()
+    .query(
+      /*sql*/ `
+      INSERT INTO acp_session_history (
+        id,
+        agent_id,
+        acp_session_id,
+        parent_conversation_id,
+        started_at,
+        completed_at,
+        status,
+        stop_reason,
+        error,
+        event_log_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+    )
+    .run(
+      row.id,
+      row.agentId,
+      row.acpSessionId,
+      row.parentConversationId,
+      row.startedAt,
+      row.completedAt ?? null,
+      row.status,
+      row.stopReason ?? null,
+      row.error ?? null,
+      row.eventLogJson ?? "[]",
+    );
+}
 
 function getSessionsHandler() {
   const route = ROUTES.find(
@@ -135,13 +122,6 @@ interface ResponseShape {
 beforeEach(() => {
   fakeInMemorySessions = [];
   clearHistory();
-  resetExecFileStub();
-  spawnMock.mockClear();
-  steerOrResumeMock.mockClear();
-  steerOrResumeImpl = defaultSteerOrResumeImpl;
-  _resetAdapterInstallCacheForTests();
-  config.setConfig({});
-  which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
 });
 
 describe("GET /v1/acp/sessions — merged in-memory + history", () => {
@@ -326,9 +306,7 @@ describe("GET /v1/acp/sessions — merged in-memory + history", () => {
     });
 
     const handler = getSessionsHandler();
-    const body = (await handler({
-      queryParams: { limit: "2" },
-    })) as ResponseShape;
+    const body = (await handler({ queryParams: { limit: "2" } })) as ResponseShape;
     expect(body.sessions).toHaveLength(2);
     expect(body.sessions.map((s) => s.id)).toEqual(["live-newest", "hist-mid"]);
   });
@@ -414,209 +392,3 @@ describe("GET /v1/acp/sessions — merged in-memory + history", () => {
     expect(body.sessions).toHaveLength(3);
   });
 });
-
-// ---------------------------------------------------------------------------
-// POST /v1/acp/spawn: auto-install on missing adapter binary
-// ---------------------------------------------------------------------------
-
-function getSpawnHandler() {
-  const route = ROUTES.find(
-    (r) => r.endpoint === "acp/spawn" && r.method === "POST",
-  );
-  if (!route) throw new Error("acp/spawn POST route not found");
-  return route.handler;
-}
-
-const SPAWN_BODY = {
-  agent: "claude",
-  task: "do something",
-  conversationId: "conv-1",
-};
-
-describe("POST /v1/acp/spawn: auto-install on missing binary", () => {
-  test("binary missing + bun present: spawn proceeds via bunx without npm", async () => {
-    which.setWhich({ bun: "/usr/local/bin/bun" });
-
-    const handler = getSpawnHandler();
-    const body = (await handler({ body: SPAWN_BODY })) as Record<
-      string,
-      unknown
-    >;
-
-    expect(body).toEqual({
-      acpSessionId: "acp-route-session",
-      protocolSessionId: "proto-route-session",
-      agent: "claude",
-    });
-    expect(execFileMock).not.toHaveBeenCalled();
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    const agentConfigArg = (spawnMock.mock.calls[0] as unknown[])[1] as {
-      command: string;
-      args: string[];
-      adapterCommand?: string;
-    };
-    expect(agentConfigArg.command).toBe("bun");
-    expect(agentConfigArg.args).toEqual([
-      "x",
-      "--bun",
-      "@agentclientprotocol/claude-agent-acp",
-    ]);
-    expect(agentConfigArg.adapterCommand).toBe("claude-agent-acp");
-  });
-
-  test("known command: installs the mapped package and spawn proceeds", 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;
-      },
-    });
-
-    const handler = getSpawnHandler();
-    const body = (await handler({ body: SPAWN_BODY })) as Record<
-      string,
-      unknown
-    >;
-
-    expect(body).toEqual({
-      acpSessionId: "acp-route-session",
-      protocolSessionId: "proto-route-session",
-      agent: "claude",
-    });
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    expect(execFileMock).toHaveBeenCalledTimes(1);
-    expect(execFileMock.mock.calls[0][1]).toEqual([
-      "i",
-      "-g",
-      "@agentclientprotocol/claude-agent-acp",
-    ]);
-  });
-
-  test("npm failure: FailedDependencyError carries hint and failure reason", async () => {
-    which.setWhich({});
-    execScripts.set("npm i", {
-      error: new Error("EACCES: permission denied"),
-    });
-
-    const handler = getSpawnHandler();
-    const promise = handler({ body: SPAWN_BODY });
-    await expect(promise).rejects.toBeInstanceOf(FailedDependencyError);
-    await expect(promise).rejects.toThrow(
-      /claude-agent-acp is not on PATH.*npm i -g @agentclientprotocol\/claude-agent-acp.*auto-install failed.*EACCES/,
-    );
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
-  test("unknown command: plain hint maps to FailedDependencyError", async () => {
-    // The allowlist itself (no npm invocation for unmapped commands) is
-    // pinned in auto-install.test.ts and spawn.test.ts; this asserts only
-    // the route's transport mapping of the plain-hint failure.
-    config.setConfig({
-      agents: { custom: { command: "custom-bin", args: [] } },
-    });
-    which.setWhich({});
-
-    const handler = getSpawnHandler();
-    const promise = handler({ body: { ...SPAWN_BODY, agent: "custom" } });
-    await expect(promise).rejects.toBeInstanceOf(FailedDependencyError);
-    await expect(promise).rejects.toThrow(
-      "custom-bin is not on PATH. Install 'custom-bin' and ensure it is on PATH.",
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// POST /v1/acp/:id/steer: transparent resume of sessions not in memory
-// ---------------------------------------------------------------------------
-
-function getSteerHandler() {
-  const route = ROUTES.find(
-    (r) => r.endpoint === "acp/:id/steer" && r.method === "POST",
-  );
-  if (!route) throw new Error("acp/:id/steer POST route not found");
-  return route.handler;
-}
-
-describe("POST /v1/acp/:id/steer: resume fallback", () => {
-  test("in-memory session steers without a resume", async () => {
-    const handler = getSteerHandler();
-    const body = await handler({
-      pathParams: { id: "live-1" },
-      body: { instruction: "redirect" },
-    });
-
-    expect(body).toEqual({ acpSessionId: "live-1", steered: true });
-    expect(steerOrResumeMock).toHaveBeenCalledTimes(1);
-    expect(steerOrResumeMock.mock.calls[0][0]).toBe("live-1");
-    expect(steerOrResumeMock.mock.calls[0][1]).toBe("redirect");
-    expect(typeof steerOrResumeMock.mock.calls[0][2]).toBe("function");
-  });
-
-  test("resumed session reports the resumed flag", async () => {
-    steerOrResumeImpl = async () => ({ resumed: true });
-
-    const handler = getSteerHandler();
-    const body = await handler({
-      pathParams: { id: "gone-1" },
-      body: { instruction: "keep going" },
-    });
-
-    expect(body).toEqual({
-      acpSessionId: "gone-1",
-      steered: true,
-      resumed: true,
-    });
-  });
-
-  test("typed not-found (no session, no history row) maps to NotFoundError", async () => {
-    steerOrResumeImpl = async (id) => {
-      throw new AcpSessionNotFoundError(id);
-    };
-
-    const handler = getSteerHandler();
-    const promise = handler({
-      pathParams: { id: "missing-1" },
-      body: { instruction: "go" },
-    });
-    await expect(promise).rejects.toBeInstanceOf(NotFoundError);
-  });
-
-  test("resume failure surfaces as FailedDependencyError with the actionable hint", async () => {
-    steerOrResumeImpl = async (id) => {
-      throw new AcpResumeError(
-        new Error(
-          `ACP session "${id}" was recorded before resume support ` +
-            `(no working directory persisted) and cannot be resumed. ` +
-            `Spawn a new session instead.`,
-        ),
-      );
-    };
-
-    const handler = getSteerHandler();
-    const promise = handler({
-      pathParams: { id: "legacy-1" },
-      body: { instruction: "go" },
-    });
-    await expect(promise).rejects.toBeInstanceOf(FailedDependencyError);
-    await expect(promise).rejects.toThrow(/recorded before resume support/);
-  });
-
-  test("plain steer errors map to NotFoundError", async () => {
-    steerOrResumeImpl = async (id) => {
-      throw new Error(
-        `ACP session "${id}" is not running (status: initializing)`,
-      );
-    };
-
-    const handler = getSteerHandler();
-    const promise = handler({
-      pathParams: { id: "init-1" },
-      body: { instruction: "go" },
-    });
-    await expect(promise).rejects.toBeInstanceOf(NotFoundError);
-  });
-});

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -23,7 +23,7 @@ mock.module("../../assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
-import { findConversation } from "../../../daemon/conversation-registry.js";
+import { findConversation } from "../../../daemon/conversation-store.js";
 import { createConversation } from "../../../memory/conversation-crud.js";
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";

package/src/runtime/routes/__tests__/surface-action-routes.test.ts

@@ -42,7 +42,7 @@ const findBySurfaceCalls: string[] = [];
 const getOrCreateCalls: string[] = [];
 const rawGetCalls: Array<{ sql: string; params: unknown[] }> = [];
 
-mock.module("../../../daemon/conversation-registry.js", () => ({
+mock.module("../../../daemon/conversation-store.js", () => ({
   findConversation: (id: string) => {
     findConvCalls.push(id);
     return memoryById ?? undefined;
@@ -51,9 +51,6 @@ mock.module("../../../daemon/conversation-registry.js", () => ({
     findBySurfaceCalls.push(surfaceId);
     return memoryBySurface ?? undefined;
   },
-}));
-
-mock.module("../../../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (id: string) => {
     getOrCreateCalls.push(id);
     if (!rehydrated) {
@@ -186,7 +183,9 @@ describe("triggerSurfaceAction handler", () => {
     // SQL must filter the messages table by ui_surface payload pattern.
     expect(rawGetCalls[0]!.sql).toContain("FROM messages");
     expect(rawGetCalls[0]!.sql).toContain("LIKE");
-    expect(rawGetCalls[0]!.params).toEqual([`%"surfaceId":"surf-evicted"%`]);
+    expect(rawGetCalls[0]!.params).toEqual([
+      `%"surfaceId":"surf-evicted"%`,
+    ]);
     expect(getOrCreateCalls).toEqual(["conv-from-db"]);
     expect(rehydrated.surfaceActionCalls).toEqual([
       { surfaceId: "surf-evicted", actionId: "act-3", data: undefined },

package/src/runtime/routes/__tests__/surface-content-routes.test.ts

@@ -51,7 +51,7 @@ const findBySurfaceCalls: string[] = [];
 const getOrCreateCalls: string[] = [];
 const rawGetCalls: Array<{ sql: string; params: unknown[] }> = [];
 
-mock.module("../../../daemon/conversation-registry.js", () => ({
+mock.module("../../../daemon/conversation-store.js", () => ({
   findConversation: (id: string) => {
     findConvCalls.push(id);
     return memoryById ?? undefined;
@@ -60,9 +60,6 @@ mock.module("../../../daemon/conversation-registry.js", () => ({
     findBySurfaceCalls.push(surfaceId);
     return undefined;
   },
-}));
-
-mock.module("../../../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (id: string) => {
     getOrCreateCalls.push(id);
     if (!rehydrated) {

package/src/runtime/routes/acp-routes.test.ts

@@ -2,28 +2,25 @@
  * Tests for the ACP route handlers.
  *
  * Suites:
- *  - POST /v1/acp/spawn: resolver failure paths (acp_disabled,
- *    unknown_agent) and the body-shape guard. The binary_not_found /
- *    auto-install surface is covered in `__tests__/acp-routes.test.ts`.
+ *  - POST /v1/acp/spawn — the three failure paths produced by
+ *    `resolveAcpAgent` (acp_disabled, unknown_agent, binary_not_found).
  *  - POST /v1/acp/spawn (env injection) — CLAUDE_CODE_OAUTH_TOKEN is read
  *    from the credential broker (policy-gated + audited) and merged into
  *    `agentConfig.env` ONLY for the `claude` agent.
  *  - DELETE /v1/acp/sessions?status=completed — the bulk-clear route that
  *    wipes terminal-state rows (completed/failed/cancelled) from
- *    `acp_session_history` while leaving running/initializing rows and
- *    rows with an in-flight resume intact.
+ *    `acp_session_history` while leaving running/initializing rows intact.
  *  - DELETE /v1/acp/sessions/:id — single-row delete: completed → 200,
- *    running or mid-resume → 409, unknown id → idempotent
- *    { deleted: false }.
+ *    running → 409, unknown id → idempotent { deleted: false }.
  *
  * The spawn tests mirror the resolver's test setup using the shared
  * `installAcpConfigStub` and `installWhichStub` helpers so the host
  * environment doesn't influence the resolver's PATH preflight.
  *
- * The delete tests stub `getAcpSessionManager` so we can drive the
- * in-memory-status and pending-resume checks without spawning real ACP
- * child processes, and use the real DB (initialized via the test preload's
- * per-file workspace) to verify the row is actually removed.
+ * The single-id delete tests stub `getAcpSessionManager` so we can drive
+ * the in-memory-status check without spawning real ACP child processes,
+ * and use the real DB (initialized via the test preload's per-file
+ * workspace) to verify the row is actually removed.
  */
 
 import {
@@ -51,10 +48,8 @@ afterAll(() => {
 // in-memory-status check without spawning real ACP processes, and so the
 // env-injection spawn tests can capture the `agentConfig` arg without
 // launching a real subprocess. Stored in mutable state so individual tests
-// can plant arbitrary states / inspect capture. `pendingResumeIds` models
-// ids reserved by an in-flight resumeFromHistory (no SessionEntry yet).
+// can plant arbitrary states / inspect capture.
 const inMemoryStates = new Map<string, AcpSessionState>();
-const pendingResumeIds = new Set<string>();
 
 interface CapturedSpawn {
   agent: string;
@@ -75,9 +70,6 @@ mock.module("../../acp/index.js", () => ({
       if (!state) throw new Error(`ACP session "${id}" not found`);
       return state;
     },
-    getActiveAndPendingIds: () => [
-      ...new Set([...inMemoryStates.keys(), ...pendingResumeIds]),
-    ],
     spawn: async (
       agent: string,
       agentConfig: { env?: Record<string, string> },
@@ -234,6 +226,22 @@ describe("POST /v1/acp/spawn", () => {
     ).rejects.toThrow('Unknown agent "nonexistent"');
   });
 
+  test("throws FailedDependencyError when the agent binary is missing", async () => {
+    config.setConfig({ agents: {} });
+    which.setWhich({});
+
+    const handler = getSpawnHandler();
+    await expect(
+      handler({
+        body: {
+          agent: "codex",
+          task: "do a thing",
+          conversationId: "conv-1",
+        },
+      }),
+    ).rejects.toThrow("codex-acp is not on PATH");
+  });
+
   test("body-shape guard short-circuits before the resolver runs", async () => {
     config.setConfig({ enabled: false });
 
@@ -449,8 +457,6 @@ describe("DELETE /v1/acp/sessions?status=completed", () => {
   });
 
   beforeEach(() => {
-    inMemoryStates.clear();
-    pendingResumeIds.clear();
     getSqlite().run("DELETE FROM acp_session_history");
   });
 
@@ -476,57 +482,6 @@ describe("DELETE /v1/acp/sessions?status=completed", () => {
     ]);
   });
 
-  test("excludes terminal rows whose session is active in memory (resumed sessions)", async () => {
-    // A resumed session reuses its original id: the in-memory state is
-    // `running` while its history row still carries the old terminal
-    // status until the next terminal upsert. The bulk delete must not
-    // remove that row out from under the live session.
-    seedHistoryRow("row-resumed", "completed", 1000);
-    seedHistoryRow("row-completed", "completed", 2000);
-    inMemoryStates.set("row-resumed", {
-      id: "row-resumed",
-      agentId: "claude",
-      acpSessionId: "proto-resumed",
-      parentConversationId: "conv-test",
-      status: "running",
-      startedAt: 1000,
-    });
-
-    const handler = getBulkDeleteHandler();
-    const result = (await handler({
-      queryParams: { status: "completed" },
-    })) as {
-      deleted: number;
-    };
-    expect(result.deleted).toBe(1);
-
-    const remaining = listRows();
-    expect(remaining).toEqual([{ id: "row-resumed", status: "completed" }]);
-  });
-
-  test("excludes terminal rows whose session has a resume in flight", async () => {
-    // A resume that is still awaiting env preparation has no in-memory
-    // SessionEntry yet, but its history row (still terminal) must survive:
-    // deleting it mid-resume would let the later terminal upsert resurrect
-    // it as an orphan row.
-    seedHistoryRow("row-pending-resume", "completed", 1000);
-    seedHistoryRow("row-completed", "completed", 2000);
-    pendingResumeIds.add("row-pending-resume");
-
-    const handler = getBulkDeleteHandler();
-    const result = (await handler({
-      queryParams: { status: "completed" },
-    })) as {
-      deleted: number;
-    };
-    expect(result.deleted).toBe(1);
-
-    const remaining = listRows();
-    expect(remaining).toEqual([
-      { id: "row-pending-resume", status: "completed" },
-    ]);
-  });
-
   test("returns deleted=0 when no terminal rows are present", async () => {
     seedHistoryRow("row-running", "running", 1000);
 
@@ -604,7 +559,6 @@ describe("DELETE /v1/acp/sessions/:id", () => {
 
   beforeEach(() => {
     inMemoryStates.clear();
-    pendingResumeIds.clear();
     getDb().delete(acpSessionHistory).run();
   });
 
@@ -656,24 +610,6 @@ describe("DELETE /v1/acp/sessions/:id", () => {
     },
   );
 
-  test("returns 409 when the session has a resume in flight (not yet in memory)", async () => {
-    pendingResumeIds.add("sess-resuming");
-    insertHistoryRow({ id: "sess-resuming", status: "completed" });
-
-    const handler = getDeleteSessionHandler();
-    expect(() => handler({ pathParams: { id: "sess-resuming" } })).toThrow(
-      "resume in flight",
-    );
-
-    // Row untouched.
-    const remaining = getDb()
-      .select()
-      .from(acpSessionHistory)
-      .where(eq(acpSessionHistory.id, "sess-resuming"))
-      .all();
-    expect(remaining).toHaveLength(1);
-  });
-
   test("idempotent for unknown id — returns { deleted: false }", async () => {
     const handler = getDeleteSessionHandler();
     const result = (await handler({