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

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -576,3 +576,355 @@ describe("task_progress surface compatibility", () => {
     expect(sent.some((m) => m.type === "ui_surface_show")).toBe(true);
   });
 });
+
+describe("ui_show card content recovery", () => {
+  function shownCard(sent: ServerMessage[]): CardSurfaceData | undefined {
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    );
+    if (!show || show.surfaceType !== "card") return undefined;
+    return show.data;
+  }
+
+  test("recovers body from a copy_block-style `text` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Inbox cleaned",
+      data: { text: "Archived 1,240 emails" },
+    });
+
+    expect(result.isError).toBe(false);
+    const card = shownCard(sent);
+    expect(card?.body).toBe("Archived 1,240 emails");
+    // The alias key is not a card field; it must not survive on the surface.
+    expect((card as Record<string, unknown>).text).toBeUndefined();
+  });
+
+  test("recovers body from a confirmation-style `message` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Heads up", message: "The server will restart." },
+    });
+
+    expect(shownCard(sent)?.body).toBe("The server will restart.");
+  });
+
+  test("recovers top-level subtitle and metadata into the card", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      subtitle: "saved just now",
+      metadata: [{ label: "Total", value: "$10" }],
+      data: { body: "Done" },
+    });
+
+    const card = shownCard(sent);
+    expect(card?.subtitle).toBe("saved just now");
+    expect(card?.metadata).toEqual([{ label: "Total", value: "$10" }]);
+  });
+
+  test("title-only card with actions renders with actions intact", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Restart the server?",
+      actions: [{ id: "yes", label: "Yes" }],
+      data: {},
+    });
+
+    expect(result.isError).toBe(false);
+    expect(shownCard(sent)?.title).toBe("Restart the server?");
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(show.actions!.length).toBe(1);
+    expect(show.actions![0].label).toBe("Yes");
+  });
+
+  test("title-only card without actions renders without error", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Status update",
+      data: {},
+    });
+
+    expect(result.isError).toBe(false);
+    expect(shownCard(sent)?.title).toBe("Status update");
+  });
+
+  test("card with body and actions is interactive", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm",
+      actions: [{ id: "ok", label: "OK" }],
+      data: { body: "Are you sure?" },
+    });
+
+    expect(result.isError).toBe(false);
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(show.actions!.length).toBe(1);
+  });
+
+  // ── Body alias recovery from cross-surface keys ────────────────────
+
+  test("recovers body from choice/form-style `description` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Search results",
+      data: { description: "Found 12 matching documents." },
+    });
+
+    const card = shownCard(sent);
+    expect(card?.body).toBe("Found 12 matching documents.");
+    expect((card as Record<string, unknown>).description).toBeUndefined();
+  });
+
+  test("recovers body from work_result-style `summary` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Report", summary: "All tests passed." },
+    });
+
+    expect(shownCard(sent)?.body).toBe("All tests passed.");
+  });
+
+  test("recovers body from confirmation-style `detail` field", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Warning", detail: "This action cannot be undone." },
+    });
+
+    expect(shownCard(sent)?.body).toBe("This action cannot be undone.");
+  });
+
+  test("recovers body from top-level `description`", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Info",
+      description: "Top-level description text",
+      data: {},
+    });
+
+    expect(shownCard(sent)?.body).toBe("Top-level description text");
+  });
+
+  test("concatenates multiple body aliases when they co-occur", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Multi-alias",
+      data: {
+        description: "Found 12 documents.",
+        summary: "Search complete.",
+        detail: "Checked 3 sources.",
+      },
+    });
+
+    const body = shownCard(sent)?.body;
+    expect(body).toContain("Found 12 documents.");
+    expect(body).toContain("Search complete.");
+    expect(body).toContain("Checked 3 sources.");
+  });
+
+  // ── Title alias recovery ────────────────────────────────────────────
+
+  test("recovers title from `heading` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { heading: "Results", body: "Done." },
+    });
+
+    expect(shownCard(sent)?.title).toBe("Results");
+  });
+
+  test("recovers title from `header` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { header: "Status Update", body: "All good." },
+    });
+
+    expect(shownCard(sent)?.title).toBe("Status Update");
+  });
+
+  // ── Subtitle alias recovery ─────────────────────────────────────────
+
+  test("recovers subtitle from `subheading` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Alert", body: "Check this.", subheading: "Important" },
+    });
+
+    expect(shownCard(sent)?.subtitle).toBe("Important");
+  });
+
+  test("recovers subtitle from table-style `caption` alias", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Table Summary", body: "Data below.", caption: "Q4 2024" },
+    });
+
+    expect(shownCard(sent)?.subtitle).toBe("Q4 2024");
+  });
+
+  // ── Alias precedence ───────────────────────────────────────────────
+
+  test("canonical `body` takes precedence over aliased `description`", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { body: "Real body", description: "Should be ignored" },
+    });
+
+    expect(shownCard(sent)?.body).toBe("Real body");
+  });
+
+  test("card with recovered `description` and actions keeps actions (has content)", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm",
+      actions: [{ id: "ok", label: "OK" }],
+      data: { description: "Proceed with deployment?" },
+    });
+
+    expect(result.isError).toBe(false);
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(shownCard(sent)?.body).toBe("Proceed with deployment?");
+  });
+
+  test("recovers actions nested inside data when top-level actions is absent", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm deployment",
+      data: {
+        body: "Deploy to production?",
+        actions: [{ id: "yes", label: "Yes" }],
+      },
+    });
+
+    expect(result.isError).toBe(false);
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions).toBeDefined();
+    expect(show.actions!.length).toBe(1);
+    expect(show.actions![0].label).toBe("Yes");
+  });
+
+  test("top-level actions take precedence over data.actions", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Confirm",
+      actions: [{ id: "top", label: "Top-level" }],
+      data: {
+        body: "Which actions?",
+        actions: [{ id: "nested", label: "Nested" }],
+      },
+    });
+
+    const show = sent.find(
+      (m): m is UiSurfaceShow => m.type === "ui_surface_show",
+    )!;
+    expect(show.actions!.length).toBe(1);
+    expect(show.actions![0].label).toBe("Top-level");
+  });
+
+  test("genuinely empty card (no title, body, subtitle, metadata, template, or actions) is rejected", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: {},
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("requires content");
+    expect(sent.filter((m) => m.type === "ui_surface_show")).toHaveLength(0);
+  });
+
+  test("a card with a real body broadcasts unchanged", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      data: { title: "Plain", body: "hi" },
+    });
+
+    expect(shownCard(sent)?.body).toBe("hi");
+  });
+
+  test("a task_progress card with empty data broadcasts (template renders a shell)", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      template: "task_progress",
+      templateData: { status: "in_progress", steps: [] },
+    });
+
+    expect(result.isError).toBe(false);
+    expect(shownCard(sent)?.template).toBe("task_progress");
+  });
+});

package/src/__tests__/conversation-sync-tags.test.ts

@@ -20,7 +20,7 @@ import { publishConversationTitleChanged } from "../runtime/sync/resource-sync-e
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { waitFor } from "./helpers/wait-for.js";
 
-initializeDb();
+await initializeDb();
 
 function clearTables(): void {
   const db = getDb();

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -321,3 +321,50 @@ describe("createToolExecutor attribution threading", () => {
     expect(calls[0].context.attribution).toBeNull();
   });
 });
+
+describe("createToolExecutor isInteractive threading", () => {
+  test("uses the resolved turn-level interactivity over live client state", async () => {
+    // A scheduled/background turn (currentTurnIsNonInteractive=true) must read
+    // as non-interactive even when a client is attached (hasNoClient=false), so
+    // ask_question short-circuits instead of parking on the response backstop.
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnIsNonInteractive: true, hasNoClient: false }),
+    );
+
+    await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.isInteractive).toBe(false);
+  });
+
+  test("reflects an interactive turn as interactive", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnIsNonInteractive: false }),
+    );
+
+    await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.isInteractive).toBe(true);
+  });
+
+  test("falls back to live client state when no turn value is set", async () => {
+    // No in-flight turn resolution (e.g. tool execution outside runAgentLoop):
+    // derive interactivity from whether a client is connected.
+    const noClient = makeCapturingExecutor();
+    await makeToolFn(
+      noClient.executor,
+      makeCtx({ currentTurnIsNonInteractive: undefined, hasNoClient: true }),
+    )("file_read", { path: "/tmp/a" });
+    expect(noClient.calls[0].context.isInteractive).toBe(false);
+
+    const withClient = makeCapturingExecutor();
+    await makeToolFn(
+      withClient.executor,
+      makeCtx({ currentTurnIsNonInteractive: undefined, hasNoClient: false }),
+    )("file_read", { path: "/tmp/a" });
+    expect(withClient.calls[0].context.isInteractive).toBe(true);
+  });
+});

package/src/__tests__/conversation-usage.test.ts

@@ -48,7 +48,7 @@ import { UsageTrackingProvider } from "../providers/usage-tracking.js";
 import type { PricingUsage } from "../usage/types.js";
 import { resolvePricingForUsageWithOverrides } from "../util/pricing.js";
 
-initializeDb();
+await initializeDb();
 
 function createMockLlmConfig() {
   return {

package/src/__tests__/conversation-wipe.test.ts

@@ -14,12 +14,12 @@ import {
   getMessages,
   wipeConversation,
 } from "../memory/conversation-crud.js";
-import { getDb } from "../memory/db-connection.js";
+import { getDb, getLogsDb, getMemoryDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 
 // Initialize db once before all tests
-initializeDb();
+await initializeDb();
 
 describe("wipeConversation", () => {
   beforeEach(() => {
@@ -28,9 +28,10 @@ describe("wipeConversation", () => {
     db.run(`DELETE FROM memory_segments`);
     db.run(`DELETE FROM memory_summaries`);
     db.run(`DELETE FROM memory_embeddings`);
-    db.run(`DELETE FROM memory_jobs`);
+    // memory_jobs / llm_request_logs live in their own dedicated connections.
+    getMemoryDb()!.run(`DELETE FROM memory_jobs`);
     db.run(`DELETE FROM tool_invocations`);
-    db.run(`DELETE FROM llm_request_logs`);
+    getLogsDb()!.run(`DELETE FROM llm_request_logs`);
     db.run(`DELETE FROM messages`);
     db.run(`DELETE FROM conversations`);
   });
@@ -98,9 +99,9 @@ describe("wipeConversation", () => {
       skipIndexing: true,
     });
 
-    // Clear any jobs that might have been created by prior operations
-    const db = getDb();
-    db.run(`DELETE FROM memory_jobs`);
+    // Clear any jobs that might have been created by prior operations.
+    // memory_jobs lives in the dedicated memory connection.
+    getMemoryDb()!.run(`DELETE FROM memory_jobs`);
 
     enqueueMemoryJob("graph_extract", { conversationId: conv.id });
     enqueueMemoryJob("build_conversation_summary", {
@@ -110,7 +111,7 @@ describe("wipeConversation", () => {
     const result = wipeConversation(conv.id);
 
     const raw = (
-      getDb() as unknown as {
+      getMemoryDb() as unknown as {
         $client: import("bun:sqlite").Database;
       }
     ).$client;

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -139,6 +139,12 @@ mock.module("../memory/retrieval-budget.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     constructor() {}
     updateConfig() {}
     shouldCompact() {

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -178,6 +178,12 @@ mock.module("../memory/retrieval-budget.js", () => ({
 }));
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -175,6 +175,12 @@ mock.module("../memory/retrieval-budget.js", () => ({
 }));
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };

package/src/__tests__/conversations-import-system-filter.test.ts

@@ -35,7 +35,7 @@ import { conversations, messages } from "../memory/schema.js";
 import { ROUTES } from "../runtime/routes/conversations-import-routes.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables() {
   const db = getDb();

package/src/__tests__/copy-composer-tc-templates.test.ts

@@ -234,6 +234,23 @@ describe("guardian_decision fallback copy", () => {
     expect(copy.body.length).toBeLessThan(longName.length);
     expect(copy.body).toContain("…");
   });
+
+  test("degrades to generic copy when the payload fails to parse", () => {
+    // A payload that doesn't match the schema (here, an out-of-range
+    // `decision`) is not trusted for identity rendering — the template must
+    // still produce safe, generic copy rather than throw or leak fields.
+    const signal = buildGuardianDecisionSignal({
+      decision: "totally-bogus",
+      requesterDisplayName: "Alice",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.title).toBe("Trusted Contact Decision");
+    expect(copy.body).toBe(
+      "Someone's access request has been denied by a guardian.",
+    );
+  });
 });
 
 // ── denied template ──────────────────────────────────────────────────────────

package/src/__tests__/credential-security-invariants.test.ts

@@ -222,7 +222,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
-      "plugin-api/index.ts", // public @vellumai/plugin-api surface re-exports getSecureKeyAsync to dynamically-imported workspace plugins via the boot-time shim (compiled-binary plugin loading)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup

package/src/__tests__/db-acp-history.test.ts

@@ -319,11 +319,11 @@ describe("acp_session_history cwd migration (272)", () => {
     // Second run short-circuits on the completed checkpoint.
     expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
 
-    // Even with the checkpoint cleared (simulating crash recovery), the
+    // Even with the step checkpoint cleared (simulating crash recovery), the
     // column-existence guard makes the ALTER a no-op.
     raw
       .query(`DELETE FROM memory_checkpoints WHERE key = ?`)
-      .run("migration_acp_session_history_cwd_v1");
+      .run("step:migrateAcpSessionHistoryCwd");
     expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
 
     const columns = raw

package/src/__tests__/db-conversation-fork-lineage-migration.test.ts

@@ -3,7 +3,6 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { removeTestDbFiles } from "./assert-not-live-db.js";
 const originalBunTest = process.env.BUN_TEST;
 
 mock.module("../util/logger.js", () => ({
@@ -14,10 +13,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { getSqliteFrom } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
 import { migrateConversationForkLineage } from "../memory/migrations/183-add-conversation-fork-lineage.js";
 import * as schema from "../memory/schema.js";
-import { getDbPath } from "../util/platform.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
 function createTestDb() {
@@ -68,7 +65,6 @@ function bootstrapPreLineageConversations(raw: Database): void {
 
 function resetMigrationTestDb(): void {
   resetDbForTesting();
-  removeTestDbFiles(getDbPath());
 }
 
 describe("conversation fork lineage migration", () => {
@@ -83,9 +79,12 @@ describe("conversation fork lineage migration", () => {
   });
 
   test("fresh DB initialization includes nullable lineage columns and parent lookup index", () => {
-    initializeDb();
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapPreLineageConversations(raw);
+
+    migrateConversationForkLineage(db);
 
-    const raw = new Database(getDbPath());
     const columns = getColumnNames(raw);
 
     expect(columns).toContain("fork_parent_conversation_id");
@@ -107,7 +106,6 @@ describe("conversation fork lineage migration", () => {
 
     expect(forkColumns).toHaveLength(2);
     expect(forkColumns.every((column) => column.notnull === 0)).toBe(true);
-    raw.close();
   });
 
   test("migration upgrades the previous schema without disturbing existing conversation rows", () => {

package/src/__tests__/db-conversation-inference-profile-migration.test.ts

@@ -3,7 +3,6 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { removeTestDbFiles } from "./assert-not-live-db.js";
 import { makeMockLogger } from "./helpers/mock-logger.js";
 
 const originalBunTest = process.env.BUN_TEST;
@@ -15,11 +14,9 @@ mock.module("../util/logger.js", () => ({
 import { _resetDisplayOrderMigrationForTests } from "../memory/conversation-display-order-migration.js";
 import { _resetGroupMigrationForTests } from "../memory/conversation-group-migration.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
 import { migrateAddConversationInferenceProfile } from "../memory/migrations/227-add-conversation-inference-profile.js";
 import { migrateRenameInferenceProfileSnakeCase } from "../memory/migrations/228-rename-inference-profile-snake-case.js";
 import * as schema from "../memory/schema.js";
-import { getDbPath } from "../util/platform.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
 function createTestDb() {
@@ -73,7 +70,6 @@ function resetMigrationTestDb(): void {
   // again. Otherwise downstream tests hit `no such column: group_id`.
   _resetGroupMigrationForTests();
   _resetDisplayOrderMigrationForTests();
-  removeTestDbFiles(getDbPath());
 }
 
 describe("conversation inference profile migration", () => {
@@ -88,9 +84,13 @@ describe("conversation inference profile migration", () => {
   });
 
   test("fresh DB initialization includes nullable inference_profile column", () => {
-    initializeDb();
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreInferenceProfileConversations(raw);
+    migrateAddConversationInferenceProfile(db);
+    migrateRenameInferenceProfileSnakeCase(db);
 
-    const raw = new Database(getDbPath());
     const columns = getColumnNames(raw);
     // Migration 228 renames the camelCase column added by 227 to snake_case to
     // match the rest of the table.
@@ -106,7 +106,6 @@ describe("conversation inference profile migration", () => {
 
     expect(inferenceProfileColumn).toBeDefined();
     expect(inferenceProfileColumn?.notnull).toBe(0);
-    raw.close();
   });
 
   test("migration upgrades the previous schema without disturbing existing rows", () => {