@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/workspace-migration-backfill-installation-id.test.ts

@@ -1,320 +1,314 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mock state
-// ---------------------------------------------------------------------------
-
-const existsSyncFn = mock((_path: string): boolean => false);
-const readFileSyncFn = mock((_path: string, _enc: string): string => "");
-const writeFileSyncFn = mock((_path: string, _data: string): void => undefined);
-const randomUUIDFn = mock((): string => "generated-uuid-1234");
-const getMemoryCheckpointFn = mock((_key: string): string | null => null);
-const deleteMemoryCheckpointFn = mock((_key: string): void => undefined);
-const getExternalAssistantIdFn = mock((): string | undefined => "my-assistant");
-const homedirFn = mock((): string => "/mock-home");
-
-// ---------------------------------------------------------------------------
-// Mock modules — before importing module under test
-// ---------------------------------------------------------------------------
-
-mock.module("node:fs", () => ({
-  existsSync: existsSyncFn,
-  readFileSync: readFileSyncFn,
-  writeFileSync: writeFileSyncFn,
-}));
-
-mock.module("node:crypto", () => ({
-  randomUUID: randomUUIDFn,
-}));
-
-mock.module("node:os", () => ({
-  homedir: homedirFn,
-}));
-
-mock.module("../persistence/checkpoints.js", () => ({
-  getMemoryCheckpoint: getMemoryCheckpointFn,
-  deleteMemoryCheckpoint: deleteMemoryCheckpointFn,
-}));
-
-mock.module("../runtime/auth/external-assistant-id.js", () => ({
-  getExternalAssistantId: getExternalAssistantIdFn,
-}));
-
-// Import after mocking
+/**
+ * Tests for workspace migration `011-backfill-installation-id`.
+ *
+ * Backfills a per-user `installationId` into the lockfile entry, sourcing it
+ * from the `telemetry:installation_id` row in the assistant DB's
+ * `memory_checkpoints` table (or a fresh UUID when absent), then deletes the
+ * stale checkpoint row. The lockfile is read from the user's home directory;
+ * the checkpoint lives in `<workspace>/data/db/assistant.db`.
+ *
+ * `node:os.homedir` is mocked to a temp directory so the lockfile paths never
+ * resolve to the developer's real `~`. The checkpoint is exercised against a
+ * real temp SQLite database, so the migration's inlined `bun:sqlite` access —
+ * including the table-missing fallback paths — runs for real.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+let mockHome = "";
+const homedirFn = mock((): string => mockHome);
+mock.module("node:os", () => ({ homedir: homedirFn }));
+
 import { backfillInstallationIdMigration } from "../workspace/migrations/011-backfill-installation-id.js";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+const CHECKPOINT_KEY = "telemetry:installation_id";
+const ASSISTANT_NAME = "my-assistant";
+const UUID_RE =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+// The preload sets VELLUM_WORKSPACE_DIR under a per-process temp root; its
+// parent is a writable temp base we can carve fresh dirs out of.
+const TMP_BASE = dirname(process.env.VELLUM_WORKSPACE_DIR ?? "");
+
+let workspaceDir: string;
+let dbPath: string;
+let lockPath: string;
+let legacyLockPath: string;
+let originalAssistantName: string | undefined;
+
+beforeEach(() => {
+  originalAssistantName = process.env.VELLUM_ASSISTANT_NAME;
+  process.env.VELLUM_ASSISTANT_NAME = ASSISTANT_NAME;
+
+  mockHome = mkdtempSync(join(TMP_BASE, "vellum-migration-011-home-"));
+  workspaceDir = mkdtempSync(join(TMP_BASE, "vellum-migration-011-ws-"));
+  homedirFn.mockClear();
+
+  lockPath = join(mockHome, ".vellum.lock.json");
+  legacyLockPath = join(mockHome, ".vellum.lockfile.json");
+
+  const dbDir = join(workspaceDir, "data", "db");
+  mkdirSync(dbDir, { recursive: true });
+  dbPath = join(dbDir, "assistant.db");
+});
+
+afterEach(() => {
+  if (originalAssistantName === undefined) {
+    delete process.env.VELLUM_ASSISTANT_NAME;
+  } else {
+    process.env.VELLUM_ASSISTANT_NAME = originalAssistantName;
+  }
+  for (const dir of [mockHome, workspaceDir]) {
+    if (dir && existsSync(dir)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});
+
+function createCheckpointsTable(): void {
+  const db = new Database(dbPath);
+  try {
+    db.run(`
+      CREATE TABLE memory_checkpoints (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+  } finally {
+    db.close();
+  }
+}
+
+/** Seed the installation-ID checkpoint row, creating the table if needed. */
+function seedCheckpoint(value: string): void {
+  if (!existsSync(dbPath)) {
+    createCheckpointsTable();
+  }
+  const db = new Database(dbPath);
+  try {
+    db.run(
+      `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, 0)`,
+      [CHECKPOINT_KEY, value],
+    );
+  } finally {
+    db.close();
+  }
+}
+
+/** Read the checkpoint value directly, or null when the table/row is absent. */
+function readCheckpoint(): string | null {
+  if (!existsSync(dbPath)) {
+    return null;
+  }
+  const db = new Database(dbPath);
+  try {
+    const row = db
+      .query(`SELECT value FROM memory_checkpoints WHERE key = ?`)
+      .get(CHECKPOINT_KEY) as { value: string } | null;
+    return row?.value ?? null;
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
 
-const BASE = "/mock-home";
-const LOCK_PATH = `${BASE}/.vellum.lock.json`;
-const LEGACY_LOCK_PATH = `${BASE}/.vellum.lockfile.json`;
-const WORKSPACE_DIR = `${BASE}/.vellum/workspace`;
+/** Create an empty DB file with no tables. */
+function createEmptyDb(): void {
+  new Database(dbPath).close();
+}
 
 function makeLockfile(assistants: Array<Record<string, unknown>>): string {
   return JSON.stringify({ assistants });
 }
 
-function setupFs(fileContents: Record<string, string>): void {
-  existsSyncFn.mockImplementation((path: string) => path in fileContents);
-  readFileSyncFn.mockImplementation((path: string, _enc: string) => {
-    if (path in fileContents) return fileContents[path];
-    throw new Error(`ENOENT: ${path}`);
-  });
+function writeLock(path: string, content: string): void {
+  writeFileSync(path, content, "utf-8");
 }
 
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
+function readLockAssistants(path: string): Array<Record<string, unknown>> {
+  return JSON.parse(readFileSync(path, "utf-8")).assistants;
+}
 
 describe("011-backfill-installation-id migration", () => {
-  beforeEach(() => {
-    existsSyncFn.mockClear();
-    readFileSyncFn.mockClear();
-    writeFileSyncFn.mockClear();
-    randomUUIDFn.mockClear();
-    getMemoryCheckpointFn.mockClear();
-    deleteMemoryCheckpointFn.mockClear();
-    getExternalAssistantIdFn.mockClear();
-    homedirFn.mockClear();
-
-    // Defaults
-    homedirFn.mockReturnValue("/mock-home");
-    getExternalAssistantIdFn.mockReturnValue("my-assistant");
-    getMemoryCheckpointFn.mockReturnValue(null);
-    randomUUIDFn.mockReturnValue("generated-uuid-1234");
-  });
-
   test("no-op when no lockfile exists", () => {
-    setupFs({});
-
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).not.toHaveBeenCalled();
+    expect(existsSync(lockPath)).toBe(false);
+    expect(existsSync(legacyLockPath)).toBe(false);
   });
 
   test("no-op when lockfile has no assistants array", () => {
-    setupFs({
-      [LOCK_PATH]: JSON.stringify({ version: 1 }),
-    });
+    writeLock(lockPath, JSON.stringify({ version: 1 }));
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).not.toHaveBeenCalled();
+    expect(JSON.parse(readFileSync(lockPath, "utf-8"))).toEqual({ version: 1 });
   });
 
   test("no-op when lockfile is malformed JSON", () => {
-    setupFs({
-      [LOCK_PATH]: "{{not json",
-    });
+    writeLock(lockPath, "{{not json");
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).not.toHaveBeenCalled();
+    expect(readFileSync(lockPath, "utf-8")).toBe("{{not json");
   });
 
   test("no-op when lockfile is an array", () => {
-    setupFs({
-      [LOCK_PATH]: JSON.stringify([1, 2, 3]),
-    });
+    writeLock(lockPath, JSON.stringify([1, 2, 3]));
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).not.toHaveBeenCalled();
+    expect(JSON.parse(readFileSync(lockPath, "utf-8"))).toEqual([1, 2, 3]);
   });
 
   test("no-op when no matching assistant entry found", () => {
-    getExternalAssistantIdFn.mockReturnValue("my-assistant");
-    setupFs({
-      [LOCK_PATH]: makeLockfile([
-        { assistantId: "other-assistant", installationId: undefined },
-      ]),
-    });
+    writeLock(lockPath, makeLockfile([{ assistantId: "other-assistant" }]));
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).not.toHaveBeenCalled();
+    expect(readLockAssistants(lockPath)[0].installationId).toBeUndefined();
   });
 
   test("backfills installationId from SQLite checkpoint", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-install-id");
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
-
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
-
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [path, data] = writeFileSyncFn.mock.calls[0] as [string, string];
-    expect(path).toBe(LOCK_PATH);
-    const parsed = JSON.parse(data);
-    expect(parsed.assistants[0].installationId).toBe("sqlite-install-id");
+    seedCheckpoint("sqlite-install-id");
+    writeLock(lockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
+
+    backfillInstallationIdMigration.run(workspaceDir);
+
+    expect(readLockAssistants(lockPath)[0].installationId).toBe(
+      "sqlite-install-id",
+    );
   });
 
-  test("generates new UUID when no SQLite checkpoint exists", () => {
-    getMemoryCheckpointFn.mockReturnValue(null);
-    randomUUIDFn.mockReturnValue("new-uuid-5678");
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
+  test("generates a new UUID when the checkpoint row is absent", () => {
+    createCheckpointsTable(); // table exists, no row
+    writeLock(lockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [, data] = writeFileSyncFn.mock.calls[0] as [string, string];
-    const parsed = JSON.parse(data);
-    expect(parsed.assistants[0].installationId).toBe("new-uuid-5678");
+    expect(readLockAssistants(lockPath)[0].installationId).toMatch(UUID_RE);
   });
 
-  test("generates new UUID when SQLite table does not exist", () => {
-    getMemoryCheckpointFn.mockImplementation(() => {
-      throw new Error("no such table: memory_checkpoints");
-    });
-    randomUUIDFn.mockReturnValue("fallback-uuid");
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
-
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
-
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [, data] = writeFileSyncFn.mock.calls[0] as [string, string];
-    const parsed = JSON.parse(data);
-    expect(parsed.assistants[0].installationId).toBe("fallback-uuid");
+  test("generates a new UUID when the assistant DB does not exist", () => {
+    writeLock(lockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
+
+    backfillInstallationIdMigration.run(workspaceDir);
+
+    expect(readLockAssistants(lockPath)[0].installationId).toMatch(UUID_RE);
   });
 
-  test("skips lockfile write when entry already has installationId", () => {
-    setupFs({
-      [LOCK_PATH]: makeLockfile([
-        { assistantId: "my-assistant", installationId: "existing-id" },
-      ]),
-    });
+  test("falls back to a UUID and does not throw when the memory_checkpoints table is absent", () => {
+    createEmptyDb(); // DB file exists but has no memory_checkpoints table
+    writeLock(lockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    expect(() =>
+      backfillInstallationIdMigration.run(workspaceDir),
+    ).not.toThrow();
 
-    expect(writeFileSyncFn).not.toHaveBeenCalled();
+    expect(readLockAssistants(lockPath)[0].installationId).toMatch(UUID_RE);
   });
 
-  test("cleans up SQLite checkpoint when entry already has installationId", () => {
-    setupFs({
-      [LOCK_PATH]: makeLockfile([
-        { assistantId: "my-assistant", installationId: "existing-id" },
+  test("skips lockfile write when entry already has installationId", () => {
+    writeLock(
+      lockPath,
+      makeLockfile([
+        { assistantId: ASSISTANT_NAME, installationId: "existing-id" },
       ]),
-    });
+    );
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(deleteMemoryCheckpointFn).toHaveBeenCalledWith(
-      "telemetry:installation_id",
-    );
+    expect(readLockAssistants(lockPath)[0].installationId).toBe("existing-id");
   });
 
-  test("cleans up SQLite checkpoint after writing lockfile", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-id");
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
+  test("deletes the checkpoint row when entry already has installationId", () => {
+    seedCheckpoint("stale-id");
+    writeLock(
+      lockPath,
+      makeLockfile([
+        { assistantId: ASSISTANT_NAME, installationId: "existing-id" },
+      ]),
+    );
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    expect(deleteMemoryCheckpointFn).toHaveBeenCalledWith(
-      "telemetry:installation_id",
-    );
+    expect(readCheckpoint()).toBeNull();
   });
 
-  test("handles deleteMemoryCheckpoint throwing gracefully", () => {
-    deleteMemoryCheckpointFn.mockImplementation(() => {
-      throw new Error("no such table");
-    });
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
+  test("deletes the checkpoint row after writing the lockfile", () => {
+    seedCheckpoint("sqlite-id");
+    writeLock(lockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
 
-    // Should not throw
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
+    expect(readLockAssistants(lockPath)[0].installationId).toBe("sqlite-id");
+    expect(readCheckpoint()).toBeNull();
   });
 
   test("reads from legacy .vellum.lockfile.json when primary is absent", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-id");
-    setupFs({
-      [LEGACY_LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
-
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
-
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [path, data] = writeFileSyncFn.mock.calls[0] as [string, string];
-    expect(path).toBe(LEGACY_LOCK_PATH);
-    const parsed = JSON.parse(data);
-    expect(parsed.assistants[0].installationId).toBe("sqlite-id");
+    seedCheckpoint("sqlite-id");
+    writeLock(legacyLockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
+
+    backfillInstallationIdMigration.run(workspaceDir);
+
+    expect(readLockAssistants(legacyLockPath)[0].installationId).toBe(
+      "sqlite-id",
+    );
+    expect(existsSync(lockPath)).toBe(false);
   });
 
   test("prefers primary lockfile over legacy when both exist", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-id");
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-      [LEGACY_LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
+    seedCheckpoint("sqlite-id");
+    writeLock(lockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
+    writeLock(legacyLockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [path] = writeFileSyncFn.mock.calls[0] as [string, string];
-    expect(path).toBe(LOCK_PATH);
+    expect(readLockAssistants(lockPath)[0].installationId).toBe("sqlite-id");
+    expect(
+      readLockAssistants(legacyLockPath)[0].installationId,
+    ).toBeUndefined();
   });
 
   test("falls through to legacy lockfile when primary is malformed", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-id");
-    setupFs({
-      [LOCK_PATH]: "{{not json",
-      [LEGACY_LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
-
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
-
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [path, data] = writeFileSyncFn.mock.calls[0] as [string, string];
-    expect(path).toBe(LEGACY_LOCK_PATH);
-    const parsed = JSON.parse(data);
-    expect(parsed.assistants[0].installationId).toBe("sqlite-id");
-  });
-
-  test("always reads lockfile from homedir (per-user, not per-instance)", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-id");
+    seedCheckpoint("sqlite-id");
+    writeLock(lockPath, "{{not json");
+    writeLock(legacyLockPath, makeLockfile([{ assistantId: ASSISTANT_NAME }]));
 
-    setupFs({
-      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
-    });
+    backfillInstallationIdMigration.run(workspaceDir);
 
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
-
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [path] = writeFileSyncFn.mock.calls[0] as [string, string];
-    expect(path).toBe(LOCK_PATH);
+    expect(readLockAssistants(legacyLockPath)[0].installationId).toBe(
+      "sqlite-id",
+    );
   });
 
   test("preserves other assistants in lockfile when writing", () => {
-    getMemoryCheckpointFn.mockReturnValue("sqlite-id");
-    setupFs({
-      [LOCK_PATH]: JSON.stringify({
-        assistants: [
-          { assistantId: "other-assistant", installationId: "other-id" },
-          { assistantId: "my-assistant" },
-        ],
-      }),
-    });
-
-    backfillInstallationIdMigration.run(WORKSPACE_DIR);
-
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const [, data] = writeFileSyncFn.mock.calls[0] as [string, string];
-    const parsed = JSON.parse(data);
-    expect(parsed.assistants[0].installationId).toBe("other-id");
-    expect(parsed.assistants[1].installationId).toBe("sqlite-id");
+    seedCheckpoint("sqlite-id");
+    writeLock(
+      lockPath,
+      makeLockfile([
+        { assistantId: "other-assistant", installationId: "other-id" },
+        { assistantId: ASSISTANT_NAME },
+      ]),
+    );
+
+    backfillInstallationIdMigration.run(workspaceDir);
+
+    const assistants = readLockAssistants(lockPath);
+    expect(assistants[0].installationId).toBe("other-id");
+    expect(assistants[1].installationId).toBe("sqlite-id");
   });
 
   test("has migration id 011-backfill-installation-id", () => {

package/src/acp/__tests__/prepare-agent-env.test.ts

@@ -233,103 +233,6 @@ describe("prepareAgentEnv — claude-agent-acp gating", () => {
   });
 });
 
-describe("prepareAgentEnv - gemini gating", () => {
-  function seedVaultGeminiKey(key: string): void {
-    vaultStore.set("acp/gemini_api_key", key);
-  }
-
-  test("injects GEMINI_API_KEY from the vault via the broker when agent.env has no override", async () => {
-    seedVaultGeminiKey("vault-gem-AAA");
-
-    const prepared = await prepareAgentEnv({
-      command: "gemini",
-      args: ["--acp"],
-    });
-
-    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-AAA");
-  });
-
-  test("auto-registers metadata with acp_spawn in allowedTools when none exists", async () => {
-    seedVaultGeminiKey("vault-gem-auto-meta");
-
-    await prepareAgentEnv({ command: "gemini", args: ["--acp"] });
-
-    const meta = metadataStore.get("acp/gemini_api_key");
-    expect(meta).toBeDefined();
-    expect(meta!.allowedTools).toContain("acp_spawn");
-  });
-
-  test("a vault miss does NOT throw and spawns without GEMINI_API_KEY (key is optional)", async () => {
-    const prepared = await prepareAgentEnv({
-      command: "gemini",
-      args: ["--acp"],
-    });
-
-    expect(prepared.env).not.toHaveProperty("GEMINI_API_KEY");
-  });
-
-  test("respects explicit tool policy that excludes acp_spawn without failing the spawn", async () => {
-    metadataStore.set("acp/gemini_api_key", {
-      allowedTools: ["other_tool"],
-    });
-    seedVaultGeminiKey("vault-gem-restricted");
-
-    const prepared = await prepareAgentEnv({
-      command: "gemini",
-      args: ["--acp"],
-    });
-
-    expect(prepared.env).not.toHaveProperty("GEMINI_API_KEY");
-    const meta = metadataStore.get("acp/gemini_api_key");
-    expect(meta!.allowedTools).toEqual(["other_tool"]);
-  });
-
-  test("agent.env override wins over the vault entry and skips the broker (precedence pin)", async () => {
-    // Seed a vault value but no metadata: if the override path consulted the
-    // broker anyway, ensureAcpCredentialPolicy would create metadata here.
-    seedVaultGeminiKey("vault-gem-CCC");
-
-    const prepared = await prepareAgentEnv({
-      command: "gemini",
-      args: ["--acp"],
-      env: { GEMINI_API_KEY: "config-gem-DDD" },
-    });
-
-    expect(prepared.env?.GEMINI_API_KEY).toBe("config-gem-DDD");
-    expect(metadataStore.has("acp/gemini_api_key")).toBe(false);
-  });
-
-  test("preserves unrelated env vars on agent.env when injecting from the vault", async () => {
-    seedVaultGeminiKey("vault-gem-EEE");
-
-    const prepared = await prepareAgentEnv({
-      command: "gemini",
-      args: ["--acp"],
-      env: { NO_COLOR: "1" },
-    });
-
-    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-EEE");
-    expect(prepared.env?.NO_COLOR).toBe("1");
-  });
-
-  test("does NOT mutate the caller's agentConfig", async () => {
-    seedVaultGeminiKey("vault-gem-GGG");
-    const original = {
-      command: "gemini",
-      args: ["--acp"],
-      env: { OTHER: "keep" },
-    };
-    const beforeEnv = { ...original.env };
-
-    const prepared = await prepareAgentEnv(original);
-
-    expect(prepared).not.toBe(original);
-    expect(prepared.env).not.toBe(original.env);
-    expect(original.env).toEqual(beforeEnv);
-    expect(original.env).not.toHaveProperty("GEMINI_API_KEY");
-  });
-});
-
 describe("prepareAgentEnv - codex-acp gating", () => {
   function seedVaultOpenaiKey(key: string): void {
     vaultStore.set("acp/openai_api_key", key);

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

@@ -75,6 +75,8 @@ function buildSessionWithFakeProcess(opts: {
     initialize: () => Promise.resolve(),
     createSession: () => Promise.resolve(opts.protocolSessionId),
     cancel: () => Promise.resolve(),
+    markStderr: () => 0,
+    stderrSince: () => "",
   };
 
   // Match spawn()'s wiring: pre-create the buffer and route emitted updates