@vellumai/assistant 0.10.0 → 0.10.1-staging.1

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();
     }

package/src/__tests__/mtime-cache.test.ts

@@ -0,0 +1,375 @@
+/**
+ * Tests for the per-surface mtime cache — the pull-based replacement for
+ * PluginSourceWatcher.
+ *
+ * Each test materializes a synthetic plugin directory under a per-file
+ * tempdir, then exercises observable behavior: cache hit (same mtime),
+ * cache miss (changed mtime → re-import), plugin deletion (eviction),
+ * and hook collection across multiple plugins.
+ */
+import { mkdirSync, rmSync, utimesSync,writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+
+import {
+  _inspectHookCacheForTests,
+  _inspectToolCacheForTests,
+  getCachedUserTools,
+  getUserHooksFor,
+  populateCacheAtBoot,
+  resetPluginCacheForTests,
+} from "../plugins/mtime-cache.js";
+
+// ─── Test fixtures ───────────────────────────────────────────────────────────
+
+const ROOT = join(
+  tmpdir(),
+  `vellum-mtime-cache-test-${process.pid}-${Date.now()}`,
+);
+
+const PLUGINS_DIR = join(ROOT, "plugins");
+
+function ensurePluginsDir(): void {
+  rmSync(PLUGINS_DIR, { recursive: true, force: true });
+  mkdirSync(PLUGINS_DIR, { recursive: true });
+}
+
+function freshPluginDir(name: string): string {
+  const dir = join(PLUGINS_DIR, name);
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function writePackageJson(dir: string, pkg: Record<string, unknown>): void {
+  writeFileSync(join(dir, "package.json"), JSON.stringify(pkg, null, 2));
+}
+
+function writeHook(dir: string, hookName: string, body: string): void {
+  const hooksDir = join(dir, "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  writeFileSync(join(hooksDir, `${hookName}.ts`), body);
+}
+
+function writeInstallMeta(dir: string, installedAt: string): void {
+  writeFileSync(
+    join(dir, "install-meta.json"),
+    JSON.stringify({ name: "test", installedAt, source: { kind: "github", owner: "test", repo: "test", ref: "main" } }, null, 2),
+  );
+}
+
+function writeTool(dir: string, toolName: string, body: string): void {
+  const toolsDir = join(dir, "tools");
+  mkdirSync(toolsDir, { recursive: true });
+  writeFileSync(join(toolsDir, `${toolName}.ts`), body);
+}
+
+/**
+ * Bump a file's mtime forward by ~2 seconds so the mtime cache detects a
+ * change. Using utimesSync avoids race conditions with filesystem mtime
+ * resolution (some platforms only have 1-second granularity).
+ */
+function touchFile(filePath: string, offsetSeconds = 2): void {
+  const now = new Date();
+  const future = new Date(now.getTime() + offsetSeconds * 1000);
+  utimesSync(filePath, future, future);
+}
+
+const SIMPLE_PKG = {
+  name: "test-plugin",
+  version: "1.0.0",
+  peerDependencies: { "@vellumai/plugin-api": "*" },
+};
+
+// ─── Setup / teardown ────────────────────────────────────────────────────────
+
+beforeAll(() => {
+  process.env.VELLUM_WORKSPACE_DIR = ROOT;
+});
+
+beforeEach(() => {
+  ensurePluginsDir();
+  resetPluginCacheForTests();
+});
+
+afterAll(() => {
+  rmSync(ROOT, { recursive: true, force: true });
+});
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("plugin mtime cache (per-surface)", () => {
+  test("populateCacheAtBoot discovers and caches hooks", async () => {
+    const dir = freshPluginDir("hook-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "hook-plugin" });
+    writeHook(
+      dir,
+      "user-prompt-submit",
+      `export default () => ({ count: 1 });`,
+    );
+
+    await populateCacheAtBoot();
+
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(1);
+  });
+
+  test("cache hit: same mtime does not re-import", async () => {
+    const dir = freshPluginDir("cached-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "cached-plugin" });
+    writeHook(
+      dir,
+      "user-prompt-submit",
+      `export default () => ({ count: 1 });`,
+    );
+
+    await populateCacheAtBoot();
+
+    const cacheBefore = _inspectHookCacheForTests();
+    expect(cacheBefore).toHaveLength(1);
+
+    // Read again — same mtime, no re-import.
+    await getUserHooksFor("user-prompt-submit");
+
+    const cacheAfter = _inspectHookCacheForTests();
+    expect(cacheAfter).toHaveLength(1);
+    expect(cacheAfter[0]?.sourceMtime).toBe(cacheBefore[0]?.sourceMtime);
+  });
+
+  test("cache miss: editing a hook file triggers re-import", async () => {
+    const dir = freshPluginDir("rebuild-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "rebuild-plugin" });
+    const hookFile = join(dir, "hooks", "user-prompt-submit.ts");
+    writeHook(
+      dir,
+      "user-prompt-submit",
+      `export default () => ({ count: 1 });`,
+    );
+
+    await populateCacheAtBoot();
+
+    const mtimeBefore = _inspectHookCacheForTests()[0]?.sourceMtime;
+
+    // Touch the hook file to bump its mtime.
+    touchFile(hookFile);
+
+    // Read again — mtime changed, re-import.
+    await getUserHooksFor("user-prompt-submit");
+
+    const mtimeAfter = _inspectHookCacheForTests()[0]?.sourceMtime;
+    expect(mtimeAfter).not.toBe(mtimeBefore);
+  });
+
+  test("plugin deletion: removing directory evicts cache entries", async () => {
+    const dir = freshPluginDir("deletable-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "deletable-plugin" });
+    writeHook(
+      dir,
+      "user-prompt-submit",
+      `export default () => ({ count: 1 });`,
+    );
+
+    await populateCacheAtBoot();
+    expect(await getUserHooksFor("user-prompt-submit")).toHaveLength(1);
+
+    // Delete the plugin directory.
+    rmSync(dir, { recursive: true, force: true });
+
+    // Read again — plugin gone, hooks evicted.
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(0);
+
+    const cacheState = _inspectHookCacheForTests();
+    expect(
+      cacheState.find((c) => c.key.startsWith("deletable-plugin/")),
+    ).toBeUndefined();
+  });
+
+  test("getUserHooksFor returns hooks from all plugins", async () => {
+    const dir1 = freshPluginDir("plugin-a");
+    writePackageJson(dir1, { ...SIMPLE_PKG, name: "plugin-a" });
+    writeHook(
+      dir1,
+      "user-prompt-submit",
+      `export default () => ({ source: "a" });`,
+    );
+
+    const dir2 = freshPluginDir("plugin-b");
+    writePackageJson(dir2, { ...SIMPLE_PKG, name: "plugin-b" });
+    writeHook(
+      dir2,
+      "user-prompt-submit",
+      `export default () => ({ source: "b" });`,
+    );
+
+    await populateCacheAtBoot();
+
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(2);
+  });
+
+  test("getUserHooksFor returns empty array when no plugins have the hook", async () => {
+    const dir = freshPluginDir("no-hook-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "no-hook-plugin" });
+
+    await populateCacheAtBoot();
+
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(0);
+  });
+
+  test("getUserHooksFor detects newly added plugin without restart", async () => {
+    const dir1 = freshPluginDir("existing-plugin");
+    writePackageJson(dir1, { ...SIMPLE_PKG, name: "existing-plugin" });
+    writeHook(dir1, "user-prompt-submit", `export default () => ({ v: 1 });`);
+
+    await populateCacheAtBoot();
+    expect(await getUserHooksFor("user-prompt-submit")).toHaveLength(1);
+
+    // Add a new plugin directory after boot.
+    const dir2 = freshPluginDir("new-plugin");
+    writePackageJson(dir2, { ...SIMPLE_PKG, name: "new-plugin" });
+    writeHook(dir2, "user-prompt-submit", `export default () => ({ v: 2 });`);
+
+    // The next read should pick it up.
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(2);
+  });
+
+  test("tools are cached and returned via getCachedUserTools", async () => {
+    const dir = freshPluginDir("tool-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "tool-plugin" });
+    writeTool(
+      dir,
+      "my-tool",
+      `export default { name: "my-tool", description: "test", parameters: { type: "object", properties: {} } };`,
+    );
+
+    await populateCacheAtBoot();
+
+    const tools = getCachedUserTools();
+    expect(tools).toHaveLength(1);
+    expect(tools[0]?.name).toBe("my-tool");
+  });
+
+  test("editing a tool file triggers re-import on next scan", async () => {
+    const dir = freshPluginDir("tool-edit-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "tool-edit-plugin" });
+    const toolFile = join(dir, "tools", "my-tool.ts");
+    writeTool(
+      dir,
+      "my-tool",
+      `export default { name: "my-tool", description: "v1", parameters: { type: "object", properties: {} } };`,
+    );
+
+    await populateCacheAtBoot();
+
+    const mtimeBefore = _inspectToolCacheForTests()[0]?.sourceMtime;
+
+    // Edit the tool file and bump mtime.
+    writeFileSync(
+      toolFile,
+      `export default { name: "my-tool", description: "v2", parameters: { type: "object", properties: {} } };`,
+    );
+    touchFile(toolFile);
+
+    // Trigger a scan by calling getUserHooksFor (which calls scanPlugins).
+    await getUserHooksFor("user-prompt-submit");
+
+    const mtimeAfter = _inspectToolCacheForTests()[0]?.sourceMtime;
+    expect(mtimeAfter).not.toBe(mtimeBefore);
+  });
+
+  test("plugin with no package.json is skipped", async () => {
+    freshPluginDir("no-manifest");
+    // No package.json written.
+
+    await populateCacheAtBoot();
+
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(0);
+  });
+
+  test("empty plugins directory returns empty arrays", async () => {
+    await populateCacheAtBoot();
+    expect(await getUserHooksFor("user-prompt-submit")).toHaveLength(0);
+    expect(getCachedUserTools()).toHaveLength(0);
+  });
+
+  test("missing plugins directory returns empty arrays", async () => {
+    rmSync(PLUGINS_DIR, { recursive: true, force: true });
+    await populateCacheAtBoot();
+    expect(await getUserHooksFor("user-prompt-submit")).toHaveLength(0);
+    expect(getCachedUserTools()).toHaveLength(0);
+  });
+
+  test("hooks are ordered by install-meta.json installedAt", async () => {
+    // Create two plugins with different install dates. The one installed
+    // later (newer timestamp) should appear second in hook execution order.
+    const dirA = freshPluginDir("plugin-alpha");
+    writePackageJson(dirA, { ...SIMPLE_PKG, name: "plugin-alpha" });
+    writeHook(
+      dirA,
+      "user-prompt-submit",
+      `export default () => ({ tag: "alpha" });`,
+    );
+    writeInstallMeta(dirA, "2026-01-15T00:00:00.000Z");
+
+    const dirB = freshPluginDir("plugin-beta");
+    writePackageJson(dirB, { ...SIMPLE_PKG, name: "plugin-beta" });
+    writeHook(
+      dirB,
+      "user-prompt-submit",
+      `export default () => ({ tag: "beta" });`,
+    );
+    writeInstallMeta(dirB, "2026-01-01T00:00:00.000Z"); // earlier install
+
+    await populateCacheAtBoot();
+
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(2);
+
+    // beta was installed earlier (Jan 1) so it should come first.
+    const results = hooks.map((fn) => (fn as unknown as () => { tag: string })());
+    expect(results[0]!.tag).toBe("beta");
+    expect(results[1]!.tag).toBe("alpha");
+  });
+
+  test("plugin without install-meta.json sorts after dated plugins", async () => {
+    const dirDated = freshPluginDir("dated-plugin");
+    writePackageJson(dirDated, { ...SIMPLE_PKG, name: "dated-plugin" });
+    writeHook(
+      dirDated,
+      "user-prompt-submit",
+      `export default () => ({ tag: "dated" });`,
+    );
+    writeInstallMeta(dirDated, "2026-01-01T00:00:00.000Z");
+
+    const dirUndated = freshPluginDir("undated-plugin");
+    writePackageJson(dirUndated, { ...SIMPLE_PKG, name: "undated-plugin" });
+    writeHook(
+      dirUndated,
+      "user-prompt-submit",
+      `export default () => ({ tag: "undated" });`,
+    );
+    // No install-meta.json — falls back to birthtime, which is "now"
+    // (later than the dated plugin's Jan 1 install date).
+
+    await populateCacheAtBoot();
+
+    const hooks = await getUserHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(2);
+
+    const results = hooks.map((fn) => (fn as unknown as () => { tag: string })());
+    expect(results[0]!.tag).toBe("dated");
+    expect(results[1]!.tag).toBe("undated");
+  });
+});

package/src/__tests__/non-member-access-request.test.ts

@@ -71,7 +71,7 @@ import { notifyGuardianOfAccessRequest } from "../runtime/access-request-helper.
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -86,7 +86,6 @@ const TEST_BEARER_TOKEN = "test-token";
  */
 function resetState(): string {
   const db = getDb();
-  db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
   db.run("DELETE FROM notification_events");

package/src/__tests__/notification-candidate-guardian-context.test.ts

@@ -0,0 +1,203 @@
+/**
+ * DB-backed tests for guardian-context enrichment of notification conversation
+ * candidates.
+ *
+ * `buildConversationCandidates` counts each candidate's pending guardian
+ * requests through the canonical store's conversation-scope query, which
+ * matches both a request's source conversation and any conversation its card
+ * was delivered to. These tests lock that wiring — in particular that a
+ * request delivered to a conversation different from its synthetic source is
+ * still counted for the conversation that shows the card.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  createCanonicalGuardianDelivery,
+  createCanonicalGuardianRequest,
+  resolveCanonicalGuardianRequest,
+} from "../memory/canonical-guardian-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations } from "../memory/schema.js";
+import { recordGuardianRequestDeliveries } from "../notifications/canonical-delivery-recorder.js";
+import { buildConversationCandidates } from "../notifications/conversation-candidates.js";
+import { createDecision } from "../notifications/decisions-store.js";
+import { createDelivery } from "../notifications/deliveries-store.js";
+import { createEvent } from "../notifications/events-store.js";
+import type { NotificationChannel } from "../notifications/types.js";
+
+await initializeDb();
+
+const TEST_PRINCIPAL = "test-principal-id";
+const CHANNEL = "vellum" as NotificationChannel;
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM canonical_guardian_deliveries");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM notification_deliveries");
+  db.run("DELETE FROM notification_decisions");
+  db.run("DELETE FROM notification_events");
+  db.run("DELETE FROM conversations");
+}
+
+/**
+ * Seed a conversation the candidate builder will surface: a "sent" notification
+ * delivery wired event -> decision -> delivery -> conversation on `channel`.
+ */
+function seedCandidateConversation(
+  conversationId: string,
+  channel: NotificationChannel = CHANNEL,
+): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations)
+    .values({
+      id: conversationId,
+      title: "Test thread",
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+
+  const eventId = `evt-${conversationId}`;
+  const decisionId = `dec-${conversationId}`;
+  createEvent({
+    id: eventId,
+    sourceEventName: "schedule.notify",
+    sourceChannel: channel,
+    sourceContextId: conversationId,
+    attentionHints: {
+      requiresAction: false,
+      urgency: "low",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    payload: {},
+  });
+  createDecision({
+    id: decisionId,
+    notificationEventId: eventId,
+    shouldNotify: true,
+    selectedChannels: [channel],
+    reasoningSummary: "test",
+    confidence: 1,
+    fallbackUsed: false,
+  });
+  createDelivery({
+    id: `del-${conversationId}`,
+    notificationDecisionId: decisionId,
+    channel,
+    destination: "dest",
+    status: "sent",
+    attempt: 1,
+    sentAt: now,
+    conversationId,
+  });
+}
+
+function candidateFor(
+  conversationId: string,
+  channel: NotificationChannel = CHANNEL,
+) {
+  const set = buildConversationCandidates([channel]);
+  return set[channel]?.find((c) => c.conversationId === conversationId);
+}
+
+describe("buildConversationCandidates guardian enrichment", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("counts pending requests via both source and delivery conversation scope", () => {
+    const convId = "conv-guardian";
+    seedCandidateConversation(convId);
+
+    // (1) pending request whose SOURCE conversation is the candidate.
+    createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: convId,
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+
+    // (2) pending request with a synthetic source id whose card was DELIVERED
+    // to the candidate conversation (a different conversation than its source).
+    const delivered = createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      conversationId: "access-req-xyz",
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+    createCanonicalGuardianDelivery({
+      requestId: delivered.id,
+      destinationChannel: CHANNEL,
+      destinationConversationId: convId,
+    });
+
+    expect(
+      candidateFor(convId)?.guardianContext?.pendingUnresolvedRequestCount,
+    ).toBe(2);
+  });
+
+  test("omits guardian context when the conversation's only request is resolved", () => {
+    const convId = "conv-resolved";
+    seedCandidateConversation(convId);
+
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: convId,
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+    resolveCanonicalGuardianRequest(req.id, "pending", { status: "approved" });
+
+    // The conversation still surfaces as a candidate (it had a delivery), but
+    // with no guardian context since nothing is pending.
+    const candidate = candidateFor(convId);
+    expect(candidate).toBeDefined();
+    expect(candidate?.guardianContext).toBeUndefined();
+  });
+
+  test("counts a Slack channel card recorded through the real recorder", () => {
+    const SLACK = "slack" as NotificationChannel;
+    const convId = "conv-slack-card";
+    seedCandidateConversation(convId, SLACK);
+
+    // Channel-only access request: a synthetic source conversation, card
+    // delivered to a Slack chat. The recorder records the card's internal
+    // conversation, so the Slack candidate counts it.
+    const req = createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "access-req-synthetic",
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+    recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [
+        {
+          channel: "slack",
+          destination: "slack-chat-1",
+          status: "sent",
+          conversationId: convId,
+          messageId: "ts-1",
+        },
+      ],
+    });
+
+    expect(
+      candidateFor(convId, SLACK)?.guardianContext
+        ?.pendingUnresolvedRequestCount,
+    ).toBe(1);
+  });
+});

package/src/__tests__/notification-guardian-path.test.ts

@@ -78,7 +78,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { conversations } from "../memory/schema.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function ensureConversation(id: string): void {
   const db = getDb();

package/src/__tests__/notification-schedule-notify-dedup.test.ts

@@ -27,7 +27,7 @@ import { createEvent } from "../notifications/events-store.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type { NotificationDecision } from "../notifications/types.js";
 
-initializeDb();
+await initializeDb();
 
 beforeEach(() => {
   getDb().delete(notificationEvents).run();

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -17,7 +17,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { getProvider } from "../oauth/oauth-store.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
 
-initializeDb();
+await initializeDb();
 seedOAuthProviders();
 
 describe("oauth provider profiles (DB-seeded)", () => {

package/src/__tests__/oauth-provider-visibility.test.ts

@@ -29,7 +29,7 @@ import { isProviderVisible } from "../oauth/provider-visibility.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 /** Create a minimal AssistantConfig for testing. */
 function makeConfig(): AssistantConfig {

package/src/__tests__/oauth-store.test.ts

@@ -72,7 +72,7 @@ import { seedOAuthProviders } from "../oauth/seed-providers.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { getMockFetchCalls, mockFetch, resetMockFetch } from "./mock-fetch.js";
 
-initializeDb();
+await initializeDb();
 
 /** Seed a minimal provider row for FK satisfaction. */
 function seedTestProvider(provider = "github"): void {

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -40,7 +40,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { persistUnsendableImageDowngrades } from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/__tests__/persist-unsendable-image.test.ts

@@ -27,7 +27,7 @@ import {
 } from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();