@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/gateway-flag-listener.test.ts

@@ -0,0 +1,236 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer, type Server, type Socket } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach,beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Isolated temp directory for the IPC socket
+// ---------------------------------------------------------------------------
+const testRoot = mkdtempSync(join(tmpdir(), "flag-listener-test-"));
+const socketPath = join(testRoot, "gateway.sock");
+
+// ---------------------------------------------------------------------------
+// Mock socket-path resolution to use our test socket
+// ---------------------------------------------------------------------------
+mock.module("../ipc/socket-path.js", () => ({
+  resolveIpcSocketPath: (_name: string) => ({
+    path: socketPath,
+    source: "workspace" as const,
+  }),
+  getAssistantSocketPath: () => join(testRoot, "assistant.sock"),
+}));
+
+// ---------------------------------------------------------------------------
+// Track calls to refreshOverridesFromGateway
+// ---------------------------------------------------------------------------
+let refreshCallCount = 0;
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  refreshOverridesFromGateway: async () => {
+    refreshCallCount++;
+  },
+  initFeatureFlagOverrides: async () => {},
+  clearFeatureFlagOverridesCache: () => {},
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+
+// ---------------------------------------------------------------------------
+// Track calls to publishSyncInvalidation so we can assert the listener
+// fans flag changes out onto the SSE hub.
+// ---------------------------------------------------------------------------
+let publishedTagSets: string[][] = [];
+
+mock.module("../runtime/sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: async (tags: string[]) => {
+    publishedTagSets.push([...tags]);
+    return { type: "sync_changed", tags };
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic imports (after mock.module)
+// ---------------------------------------------------------------------------
+const { startGatewayFlagListener, stopGatewayFlagListener } = await import(
+  "../ipc/gateway-flag-listener.js"
+);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTestServer(): {
+  server: Server;
+  clients: Set<Socket>;
+  emit: (event: string, data?: unknown) => void;
+  waitForClient: () => Promise<Socket>;
+} {
+  const clients = new Set<Socket>();
+  const clientWaiters: Array<(socket: Socket) => void> = [];
+
+  const server = createServer((socket) => {
+    clients.add(socket);
+    socket.on("close", () => clients.delete(socket));
+    const waiter = clientWaiters.shift();
+    if (waiter) waiter(socket);
+  });
+
+  return {
+    server,
+    clients,
+    emit: (event: string, data?: unknown) => {
+      const payload = JSON.stringify({ event, data }) + "\n";
+      for (const client of clients) {
+        if (!client.destroyed) client.write(payload);
+      }
+    },
+    waitForClient: () =>
+      new Promise((resolve) => {
+        if (clients.size > 0) {
+          resolve(clients.values().next().value!);
+          return;
+        }
+        clientWaiters.push(resolve);
+      }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("gateway-flag-listener", () => {
+  let testServer: ReturnType<typeof createTestServer>;
+
+  beforeEach(() => {
+    mkdirSync(testRoot, { recursive: true });
+    refreshCallCount = 0;
+    publishedTagSets = [];
+    testServer = createTestServer();
+  });
+
+  afterEach(async () => {
+    stopGatewayFlagListener();
+    await new Promise<void>((resolve) => {
+      for (const client of testServer.clients) {
+        if (!client.destroyed) client.destroy();
+      }
+      testServer.server.close(() => resolve());
+    });
+    try {
+      rmSync(socketPath, { force: true });
+    } catch {
+      // best effort
+    }
+  });
+
+  test("refreshes flag cache on connect and on feature_flags_changed event", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(1);
+
+    testServer.emit("feature_flags_changed");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(2);
+  });
+
+  test("broadcasts feature-flags sync_changed when flags change", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Connect refresh should not broadcast — only an actual change does.
+    expect(publishedTagSets.length).toBe(0);
+
+    testServer.emit("feature_flags_changed");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(publishedTagSets.length).toBe(1);
+    expect(publishedTagSets[0]).toEqual([
+      "feature-flags:client",
+      "feature-flags:assistant",
+    ]);
+  });
+
+  test("ignores non-flag events", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    const countAfterConnect = refreshCallCount;
+
+    testServer.emit("some_other_event");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(countAfterConnect);
+  });
+
+  test("reconnects on disconnect and handles events on new connection", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    const firstClient = await testServer.waitForClient();
+
+    // Wait for the close event to propagate back to the server before
+    // setting up the next waitForClient — otherwise waitForClient might
+    // resolve with the old (now-destroyed) socket that is still in the set.
+    await new Promise<void>((resolve) => {
+      firstClient.on("close", resolve);
+      firstClient.destroy();
+    });
+
+    // Wait for reconnect (initial backoff is 1s)
+    const secondClient = await Promise.race([
+      testServer.waitForClient(),
+      new Promise<null>((r) => setTimeout(() => r(null), 3000)),
+    ]);
+
+    expect(secondClient).not.toBeNull();
+
+    await new Promise((r) => setTimeout(r, 100));
+    const countAfterReconnect = refreshCallCount;
+    expect(countAfterReconnect).toBeGreaterThan(0);
+
+    const payload =
+      JSON.stringify({ event: "feature_flags_changed" }) + "\n";
+    secondClient!.write(payload);
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(refreshCallCount).toBe(countAfterReconnect + 1);
+  });
+
+  test("stopGatewayFlagListener cleans up and does not reconnect", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+
+    stopGatewayFlagListener();
+    await new Promise((r) => setTimeout(r, 50));
+
+    const initialClientCount = testServer.clients.size;
+
+    // Wait past reconnect backoff — should not reconnect
+    await new Promise((r) => setTimeout(r, 1500));
+
+    expect(testServer.clients.size).toBeLessThanOrEqual(initialClientCount);
+  });
+});

package/src/__tests__/gemini-provider.test.ts

@@ -75,6 +75,12 @@ mock.module("@google/genai", () => ({
     };
   },
   ApiError: FakeApiError,
+  ThinkingLevel: {
+    MINIMAL: "MINIMAL",
+    LOW: "LOW",
+    MEDIUM: "MEDIUM",
+    HIGH: "HIGH",
+  },
 }));
 
 // Import after mocking
@@ -223,6 +229,104 @@ describe("GeminiProvider", () => {
     expect(config.systemInstruction).toBe("You are a helpful assistant.");
   });
 
+  // -----------------------------------------------------------------------
+  // Thinking config
+  // -----------------------------------------------------------------------
+  test("omits thinkingConfig when no thinking config is supplied", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
+  test("maps wire { type: 'adaptive', level, streamThinking } to Gemini thinkingConfig", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      {
+        config: {
+          thinking: {
+            type: "adaptive",
+            level: "high",
+            streamThinking: false,
+          },
+        },
+      },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "HIGH",
+      includeThoughts: false,
+    });
+  });
+
+  test("maps wire { type: 'disabled' } to MINIMAL thinking level", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { thinking: { type: "disabled" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "MINIMAL",
+      includeThoughts: false,
+    });
+  });
+
+  test("omits thinkingConfig for models that do not support thinking", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    // gemini-2.5-flash-lite has supportsThinking: false in the catalog; the
+    // provider must not forward thinking params even when a thinking config is
+    // supplied (gemini is in THINKING_AWARE_PROVIDERS, so retry.ts no longer
+    // strips them).
+    const liteProvider = new GeminiProvider(
+      "test-api-key",
+      "gemini-2.5-flash-lite",
+    );
+    await liteProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      {
+        config: {
+          thinking: { type: "adaptive", level: "high", streamThinking: false },
+        },
+      },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
+  test("omits thinkingConfig when wire shape is adaptive with no extras", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { thinking: { type: "adaptive" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    // No level/streamThinking → omit so Google's per-model default applies
+    // (Gemini 3.x defaults to "medium" with dynamic thinking).
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
   // -----------------------------------------------------------------------
   // Tool definitions
   // -----------------------------------------------------------------------

package/src/__tests__/guardian-action-sweep.test.ts

@@ -28,7 +28,7 @@ import {
   stopGuardianActionSweep,
   sweepExpiredGuardianActions,
 } from "../calls/guardian-action-sweep.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   createGuardianActionDelivery,
@@ -38,6 +38,7 @@ import {
   updateDeliveryStatus,
 } from "../memory/guardian-action-store.js";
 import { conversations } from "../memory/schema.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -73,7 +74,7 @@ describe("guardian-action-sweep", () => {
 
   afterAll(() => {
     stopGuardianActionSweep();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("sweepExpiredGuardianActions expires requests past their expiresAt", async () => {

package/src/__tests__/guardian-dispatch.test.ts

@@ -56,7 +56,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     }
     return mockEmitResult;
   },
-  registerBroadcastFn: () => {},
 }));
 
 import {

package/src/__tests__/guardian-outbound-http.test.ts

@@ -88,7 +88,7 @@ globalThis.fetch = (async (
 // Now import modules under test (after mocks are in place)
 // ---------------------------------------------------------------------------
 
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { updateSessionDelivery } from "../runtime/channel-verification-service.js";
 import {
@@ -102,13 +102,14 @@ import {
   resendOutbound,
   startOutbound,
 } from "../runtime/verification-outbound-actions.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 // Initialize the database (creates all tables)
 initializeDb();
 
 afterAll(() => {
   globalThis.fetch = originalFetch;
-  resetDb();
+  resetDbForTesting();
 });
 
 function resetTables(): void {
@@ -280,11 +281,13 @@ describe("startOutbound", () => {
     expect(voiceCallInitCalls.length).toBe(1);
   });
 
-  test("unsupported channel returns unsupported_channel", async () => {
-    // Cast to bypass type checking for test purposes
-    const result = await startOutbound({ channel: "email" as never });
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("unsupported_channel");
+  test("email channel creates outbound session", async () => {
+    const result = await startOutbound({
+      channel: "email",
+      destination: "user@example.com",
+    });
+    expect(result.success).toBe(true);
+    expect(result.channel).toBe("email");
   });
 });
 

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -156,9 +156,54 @@ mock.module("../daemon/skill-memory-refresh.js", () => ({
   refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
 
-mock.module("../util/platform.js", () => ({
-  getWorkspaceSkillsDir: () => "/tmp/test-skills",
-}));
+mock.module("../util/platform.js", () => {
+  const stub = () => "/tmp/test-stub";
+  return {
+    getWorkspaceSkillsDir: () => "/tmp/test-skills",
+    vellumRoot: stub,
+    isMacOS: () => false,
+    isLinux: () => true,
+    isWindows: () => false,
+    getPlatformName: () => "linux",
+    normalizeAssistantId: (id: string) => id,
+    getDataDir: stub,
+    getEmbeddingModelsDir: stub,
+    getSandboxRootDir: stub,
+    getSandboxWorkingDir: stub,
+    getSoundsDir: stub,
+    getAvatarDir: stub,
+    AVATAR_IMAGE_FILENAME: "avatar-image.png",
+    getAvatarImagePath: stub,
+    getXdgVellumConfigDirName: () => ".vellum",
+    getPidPath: stub,
+    getDbPath: stub,
+    getLogsDir: stub,
+    getHistoryPath: stub,
+    getProtectedDir: stub,
+    getSignalsDir: stub,
+    getDaemonStderrLogPath: stub,
+    getDaemonStartupLockPath: stub,
+    getExternalDir: stub,
+    getBinDir: stub,
+    getDotEnvPath: stub,
+    getEmbedWorkerPidPath: stub,
+    getWorkspaceDir: stub,
+    getWorkspaceDirDisplay: stub,
+    getWorkspaceConfigPath: stub,
+    getWorkspaceHooksDir: stub,
+    getWorkspacePluginsDir: stub,
+    getWorkspaceRoutesDir: stub,
+    getDeprecatedDir: stub,
+    getConversationsDir: stub,
+    getWorkspacePromptPath: stub,
+    getProfilerRootDir: stub,
+    getProfilerRunsDir: stub,
+    getProfilerRunDir: stub,
+    getSkillRuntimePath: stub,
+    getBundledBunPath: () => undefined,
+    ensureDataDir: () => {},
+  };
+});
 
 mock.module("../daemon/handlers/shared.js", () => ({
   CONFIG_RELOAD_DEBOUNCE_MS: 100,

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -92,6 +92,7 @@ mock.module("../runtime/pending-interactions.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: mock(async () => ({ id: "persisted-message-id" })),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -193,6 +194,6 @@ describe("handleConfirmationResponse canonical status sync", () => {
     // Canonical status sync is now handled inside Conversation.handleConfirmationResponse,
     // which this test mocks out — so the handler itself no longer calls resolveCanonicalGuardianRequest.
     expect(resolveCanonicalGuardianRequestMock).not.toHaveBeenCalled();
-    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
+    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow", "approved");
   });
 });

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -74,6 +74,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   // addMessage. Disk-pressure short-circuits before addMessage ever runs,
   // but the mock module must still expose every name the real module does.
   addMessage: () => Promise.resolve({ id: "mock-msg-id" }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const mockProcessMessage = mock(() => Promise.resolve({ messageId: "msg-1" }));
@@ -91,6 +92,10 @@ mock.module("../notifications/emit-signal.js", () => ({
 mock.module("../prompts/persona-resolver.js", () => ({
   GUARDIAN_PERSONA_TEMPLATE: "# User Profile\n",
   resolveGuardianPersona: () => "# User Profile\n",
+  // buildSystemPrompt now uses resolveUserSlug (for ctx) instead of
+  // resolvePersonaContext — give the mock a noop so the import
+  // doesn't fail.
+  resolveUserSlug: () => null,
 }));
 
 mock.module("../memory/conversation-title-service.js", () => ({

package/src/__tests__/heartbeat-service.test.ts

@@ -112,6 +112,10 @@ let mockGuardianPersona: string | null = null;
 mock.module("../prompts/persona-resolver.js", () => ({
   GUARDIAN_PERSONA_TEMPLATE,
   resolveGuardianPersona: () => mockGuardianPersona,
+  // buildSystemPrompt now uses resolveUserSlug (for ctx) instead of
+  // resolvePersonaContext — give the mock a noop so the import
+  // doesn't fail.
+  resolveUserSlug: () => null,
 }));
 
 // Mock conversation store
@@ -155,6 +159,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     createdConversations.push(opts);
     return { id: `conv-${++conversationIdCounter}`, ...opts };
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Mock logger — capture warn calls for unreachable-credential assertions

package/src/__tests__/helpers/mock-logger.ts

@@ -34,3 +34,29 @@ export function makeMockLogger(): unknown {
     get: (_target, prop) => (prop === "child" ? makeMockLogger : () => {}),
   });
 }
+
+/**
+ * Returns a complete mock module object for `util/logger.js`. Use this when
+ * the consumer of `mock.module("../util/logger.js", ...)` needs full export
+ * coverage — i.e. when the transitive import graph reaches `getCliLogger`,
+ * `initLogger`, or other helpers in addition to `getLogger`.
+ *
+ *   mock.module("../util/logger.js", () => createMockLoggerModule());
+ *
+ * Pass `overrides` to swap any specific export for a custom stub (e.g. an
+ * observable spy). Anything not overridden falls back to the recursive
+ * proxy logger / no-op defaults.
+ */
+export function createMockLoggerModule(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    getLogger: () => makeMockLogger(),
+    getCliLogger: () => makeMockLogger(),
+    initLogger: () => {},
+    truncateForLog: (value: string) => value,
+    pruneOldLogFiles: () => 0,
+    LOG_FILE_PATTERN: /^assistant-(\d{4}-\d{2}-\d{2})\.log$/,
+    ...overrides,
+  };
+}

package/src/__tests__/host-bash-routes.test.ts

@@ -76,6 +76,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       clientActorPrincipals.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ───────────────────────────────────────

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -88,6 +88,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       actorPrincipalByClient.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ──────────────────────────────────────────────

package/src/__tests__/host-file-routes-targeted.test.ts

@@ -73,6 +73,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       clientActors.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ──────────────────────────────────────────────

package/src/__tests__/host-shell-tool.test.ts

@@ -264,7 +264,7 @@ describe("host_bash — baseline: no sandbox isolation", () => {
 // These tests lock that boundary so any accidental addition is caught.
 
 describe("host_bash — regression: no proxied-mode additions", () => {
-  const definition = hostShellTool.getDefinition();
+  const definition = hostShellTool;
   const schemaProps = (definition.input_schema as Record<string, unknown>)
     .properties as Record<string, unknown>;
 
@@ -863,9 +863,10 @@ describe("host_bash — proxy delegation", () => {
 
   test("propagates VELLUM_UNTRUSTED_SHELL env to proxy under CES lockdown", async () => {
     // Enable CES shell lockdown via the override cache
-    const { _setOverridesForTesting } =
-      await import("../config/assistant-feature-flags.js");
-    _setOverridesForTesting({
+    const { setOverridesForTesting } = await import(
+  "./feature-flag-test-helpers.js"
+);
+    setOverridesForTesting({
       "ces-shell-lockdown": true,
     });
 
@@ -899,7 +900,7 @@ describe("host_bash — proxy delegation", () => {
         __CONVERSATION_ID: "test-conversation",
       });
     } finally {
-      _setOverridesForTesting({});
+      setOverridesForTesting({});
       restoreEnv(envSnapshot);
     }
   });

package/src/__tests__/host-transfer-routes-targeted.test.ts

@@ -85,6 +85,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       clientActors.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ──────────────────────────────────────────────

package/src/__tests__/http-conversation-lineage.test.ts

@@ -35,10 +35,11 @@ import {
   createConversation,
   updateConversationTitle,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { rawRun } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -65,7 +66,7 @@ describe("conversation lineage in HTTP reads", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("GET /v1/conversations returns forkParent for surviving parents", async () => {