@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/llm-resolver.test.ts

@@ -509,10 +509,13 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.model).toBe("claude-opus-4-7");
   });
 
-  test("thinking and contextWindow deep-merge across all five layers for non-main call sites", () => {
+  test("thinking and contextWindow deep-merge across the contributing layers for non-main call sites", () => {
     // Each layer touches a different leaf inside `thinking` and
     // `contextWindow.overflowRecovery` so we can verify deep merge composes
     // every contribution rather than wholesale-replacing the nested objects.
+    // The call site pins `siteProfile`, so the active profile is excluded — its
+    // leaves fall through to default while override, site profile, and the
+    // call-site fragment still compose.
     const llm = LLMSchema.parse({
       default: fullDefault,
       profiles: {
@@ -539,13 +542,15 @@ describe("resolveCallSiteConfig", () => {
     const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
       overrideProfile: "override",
     });
-    // Each layer's leaf survives because no higher layer touches it.
-    expect(resolved.thinking.enabled).toBe(false); // active
+    // Override, site profile, and the call-site fragment each contribute a leaf.
     expect(resolved.thinking.streamThinking).toBe(false); // override
-    expect(resolved.contextWindow.overflowRecovery.maxAttempts).toBe(7); // active
     expect(resolved.contextWindow.overflowRecovery.safetyMarginRatio).toBe(0.1); // override
     expect(resolved.contextWindow.targetBudgetRatio).toBe(0.5); // siteProfile
     expect(resolved.contextWindow.compactThreshold).toBe(0.9); // callsite
+    // The active profile is excluded (the call site pins its own profile), so
+    // its leaves fall through to default instead of contributing.
+    expect(resolved.thinking.enabled).toBe(true); // default, NOT active's false
+    expect(resolved.contextWindow.overflowRecovery.maxAttempts).toBe(3); // default, NOT active's 7
     // Untouched leaves at depth 2 fall through to default.
     expect(resolved.contextWindow.overflowRecovery.enabled).toBe(true);
     expect(
@@ -582,7 +587,9 @@ describe("resolveCallSiteConfig", () => {
     // Lower layers contribute fields the site fragment does not touch.
     expect(resolved.verbosity).toBe("high"); // from siteProfile
     expect(resolved.speed).toBe("fast"); // from override
-    expect(resolved.effort).toBe("low"); // from active
+    // The active profile is excluded when the call site pins its own profile,
+    // so `effort` falls through to default rather than active's "low".
+    expect(resolved.effort).toBe("max"); // default, NOT active's "low"
   });
 
   test("mainAgent activeProfile overrides static call-site defaults", () => {
@@ -1435,6 +1442,199 @@ describe("resolveCallSiteConfig logitBias provenance", () => {
   });
 });
 
+describe("resolveCallSiteConfig sampling-param provenance (temperature / top_p)", () => {
+  // Mirrors production: the active `balanced` profile carries `topP: 0.95` (a
+  // MiniMax tuning), while background call sites resolve to the Anthropic
+  // `cost-optimized` profile. A field-by-field deep-merge would leak the active
+  // profile's `top_p` onto those Anthropic requests.
+  const balancedActive = LLMSchema.parse({
+    default: fullDefault,
+    profiles: {
+      balanced: {
+        provider: "together",
+        model: "MiniMaxAI/MiniMax-M3",
+        topP: 0.95,
+      },
+      "cost-optimized": {
+        provider: "anthropic",
+        model: "claude-haiku-4-5-20251001",
+        effort: "low",
+        thinking: { enabled: false },
+      },
+    },
+    activeProfile: "balanced",
+  });
+
+  test("active profile's top_p does not leak into a profile-pinned call site (Option 1 + 2)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: {
+          provider: "together",
+          model: "MiniMaxAI/MiniMax-M3",
+          topP: 0.95,
+        },
+        "cost-optimized": {
+          provider: "anthropic",
+          model: "claude-haiku-4-5-20251001",
+        },
+      },
+      activeProfile: "balanced",
+      callSites: { memoryExtraction: { profile: "cost-optimized" } },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    // balanced (active) is shadowed by the pinned cost-optimized profile, so
+    // its top_p must not ride along onto the Anthropic request.
+    expect(resolved.topP).toBeNull();
+  });
+
+  test("homeGreeting / commitMessage resolve to a temperature with NO top_p", () => {
+    const greeting = resolveCallSiteConfig("homeGreeting", balancedActive);
+    expect(greeting.model).toBe("claude-haiku-4-5-20251001");
+    // Per-call-site temperature from CALL_SITE_DEFAULTS survives.
+    expect(greeting.temperature).toBe(0.7);
+    // The active profile's top_p does NOT — both together would trip
+    // Anthropic's "temperature and top_p cannot both be specified".
+    expect(greeting.topP).toBeNull();
+
+    const commit = resolveCallSiteConfig("commitMessage", balancedActive);
+    expect(commit.temperature).toBe(0.2);
+    expect(commit.topP).toBeNull();
+  });
+
+  test("profile-less call site still inherits the active profile's provider AND sampling", () => {
+    // `workflowLeaf` pins no profile, so the active profile is the legitimate
+    // fallback (Option 1 keeps it): it supplies provider/model and its own
+    // (coherent, same-provider) sampling.
+    const resolved = resolveCallSiteConfig("workflowLeaf", balancedActive);
+    expect(resolved.provider).toBe("together");
+    expect(resolved.model).toBe("MiniMaxAI/MiniMax-M3");
+    expect(resolved.topP).toBe(0.95);
+  });
+
+  test("mainAgent keeps the active profile's top_p (balanced wins there)", () => {
+    const resolved = resolveCallSiteConfig("mainAgent", balancedActive);
+    expect(resolved.model).toBe("MiniMaxAI/MiniMax-M3");
+    expect(resolved.topP).toBe(0.95);
+  });
+
+  test("an explicit call-site temperature override still wins over the winning profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: { nucleus: { topP: 0.9, temperature: 0.1 } },
+      callSites: { memoryExtraction: { profile: "nucleus", temperature: 0.5 } },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    // Call-site override wins for the field it sets.
+    expect(resolved.temperature).toBe(0.5);
+    // The winning profile's top_p (no call-site override) still applies.
+    expect(resolved.topP).toBe(0.9);
+  });
+
+  test("a higher-precedence profile that omits top_p clears a lower profile's top_p (Option 2)", () => {
+    // No site profile is involved here, so the active profile IS folded in —
+    // this isolates Option 2: the override profile wins and omits top_p, so
+    // balanced's 0.95 must be cleared rather than surviving the merge.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: {
+          provider: "together",
+          model: "MiniMaxAI/MiniMax-M3",
+          topP: 0.95,
+        },
+        plain: { provider: "anthropic", model: "claude-opus-4-7" },
+      },
+      activeProfile: "balanced",
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "plain",
+    });
+    expect(resolved.model).toBe("claude-opus-4-7");
+    expect(resolved.topP).toBeNull();
+  });
+
+  test("forceOverrideProfile: an explicit call-site temperature survives a forced profile silent on sampling", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        active: { verbosity: "low" },
+        sitep: { provider: "anthropic", model: "claude-haiku-4-5-20251001" },
+        forced: { model: "claude-opus-4-7", effort: "high" },
+      },
+      callSites: {
+        memoryExtraction: {
+          profile: "sitep",
+          temperature: 0.7,
+          maxTokens: 1000,
+        },
+      },
+      activeProfile: "active",
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "forced",
+      forceOverrideProfile: true,
+    });
+    // The forced profile floats to the top for fields it sets.
+    expect(resolved.model).toBe("claude-opus-4-7");
+    expect(resolved.effort).toBe("high");
+    // It is silent on temperature, so the deliberate call-site value survives —
+    // consistent with sibling call-site fields like maxTokens (which flow
+    // through the deep-merge).
+    expect(resolved.temperature).toBe(0.7);
+    expect(resolved.maxTokens).toBe(1000);
+  });
+
+  test("forceOverrideProfile: a forced profile that sets temperature wins over the call-site override", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        sitep: { provider: "anthropic", model: "claude-haiku-4-5-20251001" },
+        forced: { model: "claude-opus-4-7", temperature: 0.1 },
+      },
+      callSites: {
+        memoryExtraction: { profile: "sitep", temperature: 0.7 },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "forced",
+      forceOverrideProfile: true,
+    });
+    // The forced profile explicitly sets temperature, so it floats above the
+    // call-site override.
+    expect(resolved.temperature).toBe(0.1);
+  });
+
+  test("mainAgent: an explicit call-site temperature survives an active profile silent on sampling", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: { active: { model: "claude-sonnet-4-7" } },
+      callSites: { mainAgent: { temperature: 0.5 } },
+      activeProfile: "active",
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm);
+    // The active profile floats above the call-site for mainAgent but is silent
+    // on temperature, so the deliberate call-site value survives.
+    expect(resolved.model).toBe("claude-sonnet-4-7");
+    expect(resolved.temperature).toBe(0.5);
+  });
+
+  test("mainAgent: the active profile's explicit temperature wins over a call-site temperature", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: { active: { model: "claude-sonnet-4-7", temperature: 0.2 } },
+      callSites: { mainAgent: { temperature: 0.5 } },
+      activeProfile: "active",
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm);
+    // For mainAgent the active profile floats above the call-site override, so
+    // its explicit temperature wins.
+    expect(resolved.temperature).toBe(0.2);
+  });
+});
+
 describe("resolveCallSiteConfig — workflowLeaf default", () => {
   test("inherits the workspace default config rather than pinning cost-optimized", () => {
     const llm = LLMSchema.parse({

package/src/__tests__/llm-usage-store.test.ts

@@ -21,7 +21,7 @@ import {
 import type { PricingResult, UsageEventInput } from "../usage/types.js";
 
 // Initialize db once before all tests
-initializeDb();
+await initializeDb();
 
 function makeInput(overrides?: Partial<UsageEventInput>): UsageEventInput {
   return {
@@ -779,6 +779,31 @@ describe("getUsageDayBuckets", () => {
     expect(buckets[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
     expect(buckets[0].eventCount).toBe(2);
   });
+
+  test("collapses many events within a sub-bucket span without losing totals", () => {
+    // The read path pre-aggregates events into 15-minute UTC buckets in SQL
+    // before local-time bucketing. Many events inside one such window must
+    // still sum exactly, and events split across the 15-minute boundary but
+    // within the same local day must land in the same day bucket.
+    const windowStart = utcMs(2025, 3, 1, 10); // 10:00:00 UTC
+    for (let i = 0; i < 50; i++) {
+      // Spread across ~16 minutes so the events straddle a 15-minute boundary.
+      insertEventAt(windowStart + i * 20_000, {
+        inputTokens: 2,
+        outputTokens: 1,
+      });
+    }
+
+    const buckets = getUsageDayBuckets({
+      from: utcMs(2025, 3, 1),
+      to: utcMs(2025, 3, 2),
+    });
+    expect(buckets).toHaveLength(1);
+    expect(buckets[0].date).toBe("2025-03-01");
+    expect(buckets[0].totalInputTokens).toBe(100);
+    expect(buckets[0].totalOutputTokens).toBe(50);
+    expect(buckets[0].eventCount).toBe(50);
+  });
 });
 
 describe("getUsageDayBuckets — timezone-aware", () => {
@@ -1306,6 +1331,41 @@ describe("getUsageGroupBreakdown", () => {
     expect(groups[0].totalOutputTokens).toBe(125);
     expect(groups[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
     expect(groups[0].eventCount).toBe(2);
+    // No user messages were inserted, so the conversation has zero turns.
+    expect(groups[0].turnCount).toBe(0);
+  });
+
+  test("counts conversation turns from eligible user messages when grouping by conversation", () => {
+    const db = getDb();
+    const conversationId = "conv-turns-1";
+    const now = Date.now();
+    db.run(
+      `INSERT INTO conversations (id, title, created_at, updated_at) VALUES ('${conversationId}', 'Turn counting', ${now}, ${now})`,
+    );
+    // Two user turns; the second turn has two LLM calls, but the count comes
+    // from the user messages (2), not the number of LLM calls (3).
+    db.run(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1', '${conversationId}', 'user', 'first', 500)`,
+    );
+    db.run(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u2', '${conversationId}', 'user', 'second', 2000)`,
+    );
+    // Tool-result user messages are not real turns and must be excluded.
+    db.run(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('tr1', '${conversationId}', 'user', '[{"type":"tool_result","tool_use_id":"x","content":""}]', 2100)`,
+    );
+    insertEventAt(1000, { conversationId, inputTokens: 100 });
+    insertEventAt(2500, { conversationId, inputTokens: 100 });
+    insertEventAt(2600, { conversationId, inputTokens: 100 });
+
+    const groups = getUsageGroupBreakdown(
+      { from: 0, to: 5000 },
+      "conversation",
+    );
+    expect(groups).toHaveLength(1);
+    expect(groups[0].groupId).toBe(conversationId);
+    expect(groups[0].eventCount).toBe(3);
+    expect(groups[0].turnCount).toBe(2);
   });
 
   test("returns groupId null for the Other bucket when grouping by conversation and events have no conversation id", () => {
@@ -1329,6 +1389,8 @@ describe("getUsageGroupBreakdown", () => {
     expect(groups[0].groupId).toBeNull();
     expect(groups[0].totalInputTokens).toBe(300);
     expect(groups[0].eventCount).toBe(2);
+    // The Other bucket has no parent conversation, so turns are undefined.
+    expect(groups[0].turnCount).toBeNull();
   });
 
   test("returns groupId null for every row when grouping by a non-conversation dimension", () => {
@@ -1348,6 +1410,8 @@ describe("getUsageGroupBreakdown", () => {
     expect(groups.length).toBeGreaterThan(0);
     for (const row of groups) {
       expect(row.groupId).toBeNull();
+      // Turns are only computed for the conversation grouping.
+      expect(row.turnCount).toBeNull();
     }
   });
 });

package/src/__tests__/log-export-routes.test.ts

@@ -29,7 +29,7 @@ import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/log-export-routes.js";
 import { getLogsDir } from "../util/platform.js";
 
-initializeDb();
+await initializeDb();
 
 const exportRoute = ROUTES.find((r) => r.endpoint === "export")!;
 

package/src/__tests__/log-export-workspace.test.ts

@@ -38,7 +38,7 @@ mock.module("../util/secure-keys.js", () => ({
   getSecureKeyAsync: async () => undefined,
 }));
 
-import { getDb } from "../memory/db-connection.js";
+import { getDb, getLogsDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   conversations,
@@ -60,7 +60,7 @@ import {
   SYNTHETIC_OPENAI_PROJECT_KEY,
 } from "./secret-fixtures.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -552,7 +552,7 @@ describe("POST /v1/export — manifest truncatedSections", () => {
         createdAt: now + i,
       }),
     );
-    db.insert(llmRequestLogs).values(rows).run();
+    getLogsDb()!.insert(llmRequestLogs).values(rows).run();
 
     const manifest = await readManifest({ full: true });
     expect(manifest.truncatedSections).toEqual(["llm-request-logs"]);

package/src/__tests__/media-stream-server-integration.test.ts

@@ -176,6 +176,22 @@ mock.module("../calls/channel-admission-reader.js", () => ({
   getChannelAdmissionPolicy: mockGetChannelAdmissionPolicy,
 }));
 
+// Mock the inbound trust reader. handleStart awaits this and threads the
+// verdict into routeSetup so the media-stream transport enforces the same
+// gateway ACL as ConversationRelay. Tests override mockInboundVerdict.
+let mockInboundVerdict: unknown = null;
+const mockGetInboundTrustVerdict = jest.fn(
+  async (_args?: Record<string, unknown>) => mockInboundVerdict,
+);
+mock.module("../calls/inbound-trust-reader.js", () => ({
+  getInboundTrustVerdict: mockGetInboundTrustVerdict,
+  getPhoneCallerVerdict: (otherPartyNumber: string | undefined) =>
+    mockGetInboundTrustVerdict({
+      channelType: "phone",
+      actorExternalId: otherPartyNumber || undefined,
+    }),
+}));
+
 // Mock the actor trust resolver (used by handleStart to derive trust context)
 mock.module("../runtime/actor-trust-resolver.js", () => ({
   toTrustContext: jest.fn(() => ({
@@ -356,6 +372,8 @@ beforeEach(() => {
   mockGetChannelAdmissionPolicy.mockClear();
   mockAdmissionPolicy = null;
   mockAdmissionGate = null;
+  mockGetInboundTrustVerdict.mockClear();
+  mockInboundVerdict = null;
   // Reset routeSetup to default normal_call
   mockRouteSetupResult = {
     outcome: { action: "normal_call" as const, isInbound: true },
@@ -1535,4 +1553,113 @@ describe("media-stream setup outcome scenarios", () => {
       expect(speakSystemPrompt).not.toHaveBeenCalled();
     });
   });
+
+  // ── Gateway trust verdict ──────────────────────────────────────────
+  // handleStart fetches getInboundTrustVerdict for the inbound caller and
+  // threads it into routeSetup, so the media-stream transport enforces the
+  // same gateway ACL as ConversationRelay. routeSetup itself decides
+  // verdict-vs-local; these tests assert the verdict is fetched and passed.
+
+  describe("gateway trust verdict", () => {
+    test("fetches the inbound caller's verdict and threads it into routeSetup", async () => {
+      mockInboundVerdict = {
+        channelType: "phone",
+        actorExternalId: "+14155550000",
+        contactId: "contact-1",
+        channelId: "channel-1",
+        status: "verified",
+        policy: "allow",
+        resolutionFailed: false,
+      };
+
+      const mockWs = createMockWs();
+      mockSessions.set("call-verdict-thread-1", {
+        id: "call-verdict-thread-1",
+        conversationId: "conv-verdict-thread-1",
+        status: "initiated",
+        task: null,
+        startedAt: null,
+        fromNumber: "+14155550000",
+        toNumber: "+15550001111",
+      });
+
+      const session = new MediaStreamCallSession(
+        mockWs.ws,
+        "call-verdict-thread-1",
+      );
+      session.handleMessage(makeStartMessage());
+      await session.whenSetupSettled();
+
+      // Verdict fetched for the inbound caller (from number) on the phone channel.
+      expect(mockGetInboundTrustVerdict).toHaveBeenCalledWith({
+        channelType: "phone",
+        actorExternalId: "+14155550000",
+      });
+      // Verdict threaded into routeSetup.
+      expect(routeSetup).toHaveBeenCalledWith(
+        expect.objectContaining({ verdict: mockInboundVerdict }),
+      );
+    });
+
+    test("a blocked/denied member verdict is enforced (deny) on the media-stream transport", async () => {
+      // The real router returns `deny` for a member verdict whose ACL is
+      // blocked/revoked/deny; the mock reflects that outcome here.
+      mockInboundVerdict = {
+        channelType: "phone",
+        actorExternalId: "+14155550000",
+        contactId: "contact-1",
+        channelId: "channel-1",
+        status: "blocked",
+        policy: "deny",
+        resolutionFailed: false,
+      };
+      mockRouteSetupResult = {
+        outcome: {
+          action: "deny",
+          message:
+            "This number is not authorized to reach the assistant right now.",
+          logReason: "Inbound voice ACL: member blocked",
+        },
+        resolved: {
+          assistantId: "self",
+          isInbound: true,
+          otherPartyNumber: "+14155550000",
+          actorTrust: { trustClass: "unknown", memberRecord: null },
+        },
+      };
+
+      const mockWs = createMockWs();
+      mockSessions.set("call-verdict-deny-1", {
+        id: "call-verdict-deny-1",
+        conversationId: "conv-verdict-deny-1",
+        status: "initiated",
+        task: null,
+        startedAt: null,
+        fromNumber: "+14155550000",
+        toNumber: "+15550001111",
+      });
+
+      const session = new MediaStreamCallSession(
+        mockWs.ws,
+        "call-verdict-deny-1",
+      );
+      session.handleMessage(makeStartMessage());
+      await session.whenSetupSettled();
+
+      // Verdict was passed into routeSetup, which denied the caller.
+      expect(routeSetup).toHaveBeenCalledWith(
+        expect.objectContaining({ verdict: mockInboundVerdict }),
+      );
+      expect(speakSystemPrompt).toHaveBeenCalledWith(
+        expect.anything(),
+        "This number is not authorized to reach the assistant right now.",
+      );
+      expect(updateCallSession).toHaveBeenCalledWith(
+        "call-verdict-deny-1",
+        expect.objectContaining({ status: "failed" }),
+      );
+      expect(registerCallController).not.toHaveBeenCalled();
+      expect(mockStartInitialGreeting).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/__tests__/memory-jobs-worker-lanes.test.ts

@@ -110,7 +110,7 @@ mock.module("../memory/db-maintenance.js", () => ({
   maybeRunDbMaintenance: () => {},
 }));
 
-import { getDb } from "../memory/db-connection.js";
+import { getMemoryDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { runMemoryJobsOnce } from "../memory/jobs-worker.js";
@@ -118,12 +118,12 @@ import { _resetQdrantBreaker } from "../memory/qdrant-circuit-breaker.js";
 import { memoryJobs } from "../memory/schema.js";
 
 describe("memory jobs worker lane scheduling", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   beforeEach(() => {
-    const db = getDb();
+    const db = getMemoryDb()!;
     db.run("DELETE FROM memory_jobs");
     completions.length = 0;
     _resetQdrantBreaker();
@@ -185,7 +185,7 @@ describe("memory jobs worker lane scheduling", () => {
 function countSlowByStatus(
   status: "pending" | "running" | "completed",
 ): number {
-  const db = getDb();
+  const db = getMemoryDb()!;
   return db
     .select()
     .from(memoryJobs)

package/src/__tests__/memory-recall-log-store.test.ts

@@ -28,7 +28,7 @@ import {
 } from "../memory/memory-recall-log-store.js";
 import { memoryRecallLogs } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/__tests__/memory-upsert-concurrency.test.ts

@@ -60,20 +60,20 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
-import { getDb } from "../memory/db-connection.js";
+import { getDb, getMemorySqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { indexMessageNow } from "../memory/indexer.js";
 import { conversations, memorySegments, messages } from "../memory/schema.js";
 
 // Initialize DB once for the entire file. Each test cleans its own tables.
-initializeDb();
+await initializeDb();
 
 function resetTables() {
   const db = getDb();
   db.run("DELETE FROM memory_embeddings");
   db.run("DELETE FROM memory_graph_nodes");
   db.run("DELETE FROM memory_segments");
-  db.run("DELETE FROM memory_jobs");
+  getMemorySqlite()!.run("DELETE FROM memory_jobs");
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversations");
 }
@@ -550,4 +550,3 @@ describe("memory segment job atomicity under repeated indexer invocations", () =
     expect(storedSegments.length).toBe(firstCount);
   });
 });
-

package/src/__tests__/messages-after-tiebreaker.test.ts

@@ -14,7 +14,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { conversations, messages } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 const CONV_ID = "conv-tiebreaker";
 

package/src/__tests__/migration-import-from-url.test.ts

@@ -420,7 +420,7 @@ describe("handleMigrationImport — JSON {url} body", () => {
 
 describe("handleMigrationImport — no-swap path omits newer-migration warning", () => {
   test("credentials-only bundle does not inherit live-DB migration warnings", async () => {
-    // Seed the live workspace DB with a migration_* checkpoint that's NOT
+    // Seed the live workspace DB with a step:* checkpoint that's NOT
     // in the registry. validateMigrationState treats this as a "newer
     // version" and would otherwise push a warning into the report. With
     // the gate in appendNewerMigrationWarningsIfAny the warning must be
@@ -441,7 +441,7 @@ describe("handleMigrationImport — no-swap path omits newer-migration warning",
         .query(
           `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
         )
-        .run("migration_from_the_future", "1", Date.now());
+        .run("step:migrationFromTheFuture", "1", Date.now());
     } finally {
       seed.close();
     }