@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/plugins/defaults/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -1,4 +1,7 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
 
 let listPagesImpl: (workspaceDir: string) => Promise<string[]> = async () => [];
 
@@ -6,9 +9,12 @@ mock.module("../v2/page-store.js", () => ({
   listPages: (workspaceDir: string) => listPagesImpl(workspaceDir),
 }));
 
-import { getDb } from "../../../../persistence/db-connection.js";
-import { initializeDb } from "../../../../persistence/db-init.js";
-import { memoryV2ActivationLogs } from "../../../../persistence/schema/index.js";
+import {
+  clearStoredDb,
+  setStoredDb,
+} from "../../../../persistence/db-singleton.js";
+import { ensureActivationLogsSchema } from "../../../../persistence/migrations/336-move-memory-v2-activation-logs-to-memory-db.js";
+import * as schema from "../../../../persistence/schema/index.js";
 import {
   type MemoryV2ConceptRowRecord,
   recordMemoryV2ActivationLog,
@@ -16,7 +22,10 @@ import {
 import { getConceptFrequencySummary } from "../memory-v2-concept-frequency.js";
 import { sampleConfig } from "./fixtures/memory-v2-activation-fixtures.js";
 
-await initializeDb();
+// The store and aggregator resolve the dedicated memory connection through
+// the `memory` singleton slot — install a fresh in-memory DB there with the
+// relocated table's schema.
+let memorySqlite: Database;
 
 const WORKSPACE = "/tmp/memory-v2-concept-frequency-test";
 
@@ -41,16 +50,20 @@ function makeConcept(
   };
 }
 
-function resetTables(): void {
-  getDb().delete(memoryV2ActivationLogs).run();
-}
-
 describe("memory-v2-concept-frequency", () => {
   beforeEach(() => {
-    resetTables();
+    memorySqlite = new Database(":memory:");
+    ensureActivationLogsSchema(memorySqlite);
+    setStoredDb("memory", drizzle(memorySqlite, { schema }), () =>
+      memorySqlite.close(),
+    );
     listPagesImpl = async () => [];
   });
 
+  afterEach(() => {
+    clearStoredDb("memory");
+  });
+
   test("aggregates per-status counts across multiple turns", async () => {
     const conv = "conv-1";
     recordMemoryV2ActivationLog({
@@ -185,7 +198,7 @@ describe("memory-v2-concept-frequency", () => {
       config: sampleConfig,
     });
     // Backdate the just-written row — recordMemoryV2ActivationLog uses Date.now().
-    getDb().update(memoryV2ActivationLogs).set({ createdAt: 1_000 }).run();
+    memorySqlite.exec(`UPDATE memory_v2_activation_logs SET created_at = 1000`);
 
     recordMemoryV2ActivationLog({
       conversationId: "conv-1",

package/src/plugins/defaults/memory/__tests__/prompt-override.test.ts

@@ -3,13 +3,13 @@
  * (`assistant/src/memory/prompt-override.ts`) and the memory-v3
  * `resolveSelectorPrompt` built on it. Mirrors the v2 router/consolidation
  * prompt-path suites: a configured file replaces the bundled prompt, and any
- * missing / empty / oversized / non-regular / unreadable file degrades to the
- * bundled prompt with a diagnostic warning.
+ * out-of-workspace / missing / empty / oversized / non-regular / unreadable
+ * file degrades to the bundled prompt with a diagnostic warning.
  */
 import { execFileSync } from "node:child_process";
 import { mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import {
@@ -50,6 +50,7 @@ const load = (
   });
 
 describe("resolveOverridePath", () => {
+  // Pure resolution — workspace containment is enforced by loadPromptOverride.
   test("expands a leading ~/ to the home directory", () => {
     expect(resolveOverridePath("~/sub/x.md", tmpDir)).toBe(
       join(homedir(), "sub/x.md"),
@@ -91,17 +92,80 @@ describe("loadPromptOverride — usable override", () => {
     expect(warnCalls).toHaveLength(0);
   });
 
-  test("expands a leading ~/ to the home directory", () => {
+  test("honors a ~/ path that resolves inside the workspace", () => {
+    let wsUnderHome: string;
+    try {
+      wsUnderHome = mkdtempSync(join(homedir(), ".vellum-prompt-override-ws-"));
+    } catch {
+      // Home directory not writable on this platform — skip without failing.
+      return;
+    }
+    try {
+      writeFileSync(join(wsUnderHome, "x.md"), "home workspace body\n");
+      const out = loadPromptOverride({
+        overridePath: `~/${basename(wsUnderHome)}/x.md`,
+        workspaceDir: wsUnderHome,
+        log: recordingLogger,
+        label: "test prompt",
+      });
+      expect(out).toBe("home workspace body\n");
+      expect(warnCalls).toHaveLength(0);
+    } finally {
+      rmSync(wsUnderHome, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("loadPromptOverride — workspace containment", () => {
+  test("an absolute path outside the workspace is rejected", () => {
+    const outside = mkdtempSync(join(tmpdir(), "prompt-override-outside-"));
+    try {
+      const p = join(outside, "secret.md");
+      writeFileSync(p, "SENSITIVE CONTENTS\n");
+      expect(load(p)).toBeNull();
+      expect(warnCalls).toHaveLength(1);
+      expect(warnCalls[0].data.reason).toBe("outside_workspace");
+      expect(warnCalls[0].data.fallback).toBe("bundled");
+    } finally {
+      rmSync(outside, { recursive: true, force: true });
+    }
+  });
+
+  test("a relative path escaping the workspace via .. is rejected", () => {
+    const name = `prompt-override-escape-${process.pid}.md`;
+    const target = join(tmpDir, "..", name);
+    writeFileSync(target, "escaped\n");
+    try {
+      expect(load(join("..", name))).toBeNull();
+      expect(warnCalls[0].data.reason).toBe("outside_workspace");
+    } finally {
+      rmSync(target, { force: true });
+    }
+  });
+
+  test("a ~/ path outside the workspace is rejected", () => {
     const filename = `.vellum-prompt-override-test-${process.pid}.md`;
     const p = join(homedir(), filename);
     writeFileSync(p, "home body\n");
     try {
-      expect(load(`~/${filename}`)).toBe("home body\n");
-      expect(warnCalls).toHaveLength(0);
+      expect(load(`~/${filename}`)).toBeNull();
+      expect(warnCalls[0].data.reason).toBe("outside_workspace");
     } finally {
       rmSync(p, { force: true });
     }
   });
+
+  test("a symlinked directory pointing outside the workspace is rejected", () => {
+    const outside = mkdtempSync(join(tmpdir(), "prompt-override-outside-"));
+    try {
+      writeFileSync(join(outside, "secret.md"), "SENSITIVE CONTENTS\n");
+      symlinkSync(outside, join(tmpDir, "linked-dir"));
+      expect(load(join("linked-dir", "secret.md"))).toBeNull();
+      expect(warnCalls[0].data.reason).toBe("outside_workspace");
+    } finally {
+      rmSync(outside, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("loadPromptOverride — fallback to null with a diagnostic warning", () => {

package/src/plugins/defaults/memory/__tests__/table-relocation.test.ts

@@ -28,6 +28,14 @@ const { MEMORY_JOBS_RELOCATION } =
   await import("../../../../persistence/migrations/298-move-memory-jobs-to-memory-db.js");
 const { INJECTION_EVENTS_RELOCATION } =
   await import("../../../../persistence/migrations/326-move-injection-events-to-memory-db.js");
+const { ACTIVATION_LOGS_RELOCATION } =
+  await import("../../../../persistence/migrations/336-move-memory-v2-activation-logs-to-memory-db.js");
+const { RECALL_LOGS_RELOCATION } =
+  await import("../../../../persistence/migrations/337-move-memory-recall-logs-to-memory-db.js");
+const { MEMORY_V3_SELECTIONS_RELOCATION } =
+  await import("../../../../persistence/migrations/338-move-memory-v3-selections-to-memory-db.js");
+const { ACTIVATION_SESSIONS_RELOCATION } =
+  await import("../../../../persistence/migrations/339-move-activation-sessions-to-memory-db.js");
 
 await initializeDb();
 
@@ -177,3 +185,273 @@ describe("memory_v2_injection_events drain", () => {
     ]);
   });
 });
+
+describe("memory_v3_selections drain", () => {
+  test("copies every row (full copy) and drops staging", async () => {
+    const sqlite = getSqlite();
+    const memory = getMemorySqlite()!;
+
+    // Clean slate: empty live table, fresh populated staging table with the
+    // full post-283 column set.
+    memory.exec(`DELETE FROM memory_v3_selections`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."memory_v3_selections__relocating"`);
+    sqlite.exec(/*sql*/ `
+      CREATE TABLE main."memory_v3_selections__relocating" (
+        conversation_id TEXT NOT NULL,
+        turn INTEGER NOT NULL,
+        slug TEXT NOT NULL,
+        source TEXT NOT NULL,
+        pinned INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        message_id TEXT,
+        section_ordinal INTEGER,
+        section_title TEXT,
+        PRIMARY KEY (conversation_id, turn, slug)
+      )
+    `);
+
+    const insert = sqlite.prepare(
+      `INSERT INTO main."memory_v3_selections__relocating"
+         (conversation_id, turn, slug, source, pinned, created_at,
+          message_id, section_ordinal, section_title)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    insert.run("conv-1", 1, "page-a", "needle", 0, 1_000, "msg-1", 2, "Head");
+    insert.run("conv-1", 2, "page-b", "core", 1, 2_000, null, null, null);
+
+    await drainStagedTable(sqlite, MEMORY_V3_SELECTIONS_RELOCATION);
+
+    expect(existsInMain("memory_v3_selections__relocating")).toBe(false);
+
+    // Both rows landed intact, secondary attributes included.
+    const kept = memory
+      .query(
+        `SELECT conversation_id, turn, slug, source, pinned, created_at,
+                message_id, section_ordinal, section_title
+           FROM memory_v3_selections WHERE conversation_id = 'conv-1'
+           ORDER BY turn`,
+      )
+      .all();
+    expect(kept).toEqual([
+      {
+        conversation_id: "conv-1",
+        turn: 1,
+        slug: "page-a",
+        source: "needle",
+        pinned: 0,
+        created_at: 1_000,
+        message_id: "msg-1",
+        section_ordinal: 2,
+        section_title: "Head",
+      },
+      {
+        conversation_id: "conv-1",
+        turn: 2,
+        slug: "page-b",
+        source: "core",
+        pinned: 1,
+        created_at: 2_000,
+        message_id: null,
+        section_ordinal: null,
+        section_title: null,
+      },
+    ]);
+  });
+
+  test("a pre-283 legacy source NULL-fills the missing columns", async () => {
+    const sqlite = getSqlite();
+    const memory = getMemorySqlite()!;
+
+    // Staging table shaped like migration 268's original schema — no
+    // message_id / section_ordinal / section_title columns.
+    memory.exec(`DELETE FROM memory_v3_selections`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."memory_v3_selections__relocating"`);
+    sqlite.exec(/*sql*/ `
+      CREATE TABLE main."memory_v3_selections__relocating" (
+        conversation_id TEXT NOT NULL,
+        turn INTEGER NOT NULL,
+        slug TEXT NOT NULL,
+        source TEXT NOT NULL,
+        pinned INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (conversation_id, turn, slug)
+      )
+    `);
+    sqlite
+      .prepare(
+        `INSERT INTO main."memory_v3_selections__relocating"
+           (conversation_id, turn, slug, source, pinned, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+      )
+      .run("conv-legacy", 7, "page-old", "needle", 0, 5_000);
+
+    await drainStagedTable(sqlite, MEMORY_V3_SELECTIONS_RELOCATION);
+
+    expect(existsInMain("memory_v3_selections__relocating")).toBe(false);
+
+    const row = memory
+      .query(
+        `SELECT slug, created_at, message_id, section_ordinal, section_title
+           FROM memory_v3_selections WHERE conversation_id = 'conv-legacy'`,
+      )
+      .get();
+    expect(row).toEqual({
+      slug: "page-old",
+      created_at: 5_000,
+      message_id: null,
+      section_ordinal: null,
+      section_title: null,
+    });
+  });
+});
+
+describe("activation_sessions drain", () => {
+  test("copies every row and drops staging", async () => {
+    const sqlite = getSqlite();
+    const memory = getMemorySqlite()!;
+
+    memory.exec(`DELETE FROM activation_sessions`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."activation_sessions__relocating"`);
+    sqlite.exec(/*sql*/ `
+      CREATE TABLE main."activation_sessions__relocating" (
+        conversation_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    const insert = sqlite.prepare(
+      `INSERT INTO main."activation_sessions__relocating"
+         (conversation_id, created_at) VALUES (?, ?)`,
+    );
+    insert.run("conv-a", 1_000);
+    insert.run("conv-b", 2_000);
+
+    await drainStagedTable(sqlite, ACTIVATION_SESSIONS_RELOCATION);
+
+    expect(existsInMain("activation_sessions__relocating")).toBe(false);
+
+    const kept = memory
+      .query(
+        `SELECT conversation_id, created_at FROM activation_sessions
+           ORDER BY conversation_id`,
+      )
+      .all();
+    expect(kept).toEqual([
+      { conversation_id: "conv-a", created_at: 1_000 },
+      { conversation_id: "conv-b", created_at: 2_000 },
+    ]);
+  });
+});
+
+describe("memory_v2_activation_logs drain", () => {
+  test("copies every row, drops staging", async () => {
+    const sqlite = getSqlite();
+    const memory = getMemorySqlite()!;
+
+    // Clean slate: empty live table, fresh populated staging table.
+    memory.exec(`DELETE FROM memory_v2_activation_logs`);
+    sqlite.exec(
+      `DROP TABLE IF EXISTS main."memory_v2_activation_logs__relocating"`,
+    );
+    sqlite.exec(/*sql*/ `
+      CREATE TABLE main."memory_v2_activation_logs__relocating" (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        message_id TEXT,
+        turn INTEGER NOT NULL,
+        mode TEXT NOT NULL,
+        concepts_json TEXT NOT NULL,
+        skills_json TEXT NOT NULL,
+        config_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    const insert = sqlite.prepare(
+      `INSERT INTO main."memory_v2_activation_logs__relocating"
+         (id, conversation_id, message_id, turn, mode,
+          concepts_json, skills_json, config_json, created_at)
+       VALUES (?, 'conv-1', ?, ?, 'router', '[]', '[]', '{}', ?)`,
+    );
+    insert.run("act-1", "msg-1", 1, 1_000);
+    insert.run("act-2", null, 2, 2_000);
+
+    await drainStagedTable(sqlite, ACTIVATION_LOGS_RELOCATION);
+
+    // Staging dropped; the full-copy spec preserved every row and column.
+    expect(existsInMain("memory_v2_activation_logs__relocating")).toBe(false);
+    const kept = memory
+      .query<
+        { id: string; message_id: string | null; turn: number },
+        []
+      >(`SELECT id, message_id, turn FROM memory_v2_activation_logs ORDER BY id`)
+      .all();
+    expect(kept).toEqual([
+      { id: "act-1", message_id: "msg-1", turn: 1 },
+      { id: "act-2", message_id: null, turn: 2 },
+    ]);
+  });
+});
+
+describe("memory_recall_logs drain", () => {
+  test("copies every row, NULL-fills query_context on a pre-211 source, drops staging", async () => {
+    const sqlite = getSqlite();
+    const memory = getMemorySqlite()!;
+
+    // Clean slate: empty live table, fresh populated staging table shaped
+    // like a legacy source that predates the query_context column.
+    memory.exec(`DELETE FROM memory_recall_logs`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."memory_recall_logs__relocating"`);
+    sqlite.exec(/*sql*/ `
+      CREATE TABLE main."memory_recall_logs__relocating" (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        message_id TEXT,
+        enabled INTEGER NOT NULL,
+        degraded INTEGER NOT NULL,
+        provider TEXT,
+        model TEXT,
+        degradation_json TEXT,
+        semantic_hits INTEGER NOT NULL,
+        merged_count INTEGER NOT NULL,
+        selected_count INTEGER NOT NULL,
+        tier1_count INTEGER NOT NULL,
+        tier2_count INTEGER NOT NULL,
+        hybrid_search_latency_ms INTEGER NOT NULL,
+        sparse_vector_used INTEGER NOT NULL,
+        injected_tokens INTEGER NOT NULL,
+        latency_ms INTEGER NOT NULL,
+        top_candidates_json TEXT NOT NULL,
+        injected_text TEXT,
+        reason TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    const insert = sqlite.prepare(
+      `INSERT INTO main."memory_recall_logs__relocating"
+         (id, conversation_id, message_id, enabled, degraded, semantic_hits,
+          merged_count, selected_count, tier1_count, tier2_count,
+          hybrid_search_latency_ms, sparse_vector_used, injected_tokens,
+          latency_ms, top_candidates_json, created_at)
+       VALUES (?, 'conv-1', ?, 1, 0, 3, 2, 1, 1, 0, 100, 0, 300, 150, '[]', ?)`,
+    );
+    insert.run("rec-1", "msg-1", 1_000);
+    insert.run("rec-2", null, 2_000);
+
+    await drainStagedTable(sqlite, RECALL_LOGS_RELOCATION);
+
+    // Staging dropped; both rows copied with the absent legacy column
+    // NULL-filled.
+    expect(existsInMain("memory_recall_logs__relocating")).toBe(false);
+    const kept = memory
+      .query<
+        { id: string; message_id: string | null; query_context: string | null },
+        []
+      >(`SELECT id, message_id, query_context FROM memory_recall_logs ORDER BY id`)
+      .all();
+    expect(kept).toEqual([
+      { id: "rec-1", message_id: "msg-1", query_context: null },
+      { id: "rec-2", message_id: null, query_context: null },
+    ]);
+  });
+});

package/src/plugins/defaults/memory/activation-session-store.ts

@@ -1,41 +1,48 @@
-import { eq } from "drizzle-orm";
-
-import { getDb } from "../../../persistence/db-connection.js";
-import { activationSessions } from "../../../persistence/schema/index.js";
 import { getLogger } from "./logging.js";
+import { memorySqliteOrNull } from "./memory-db.js";
 
 const log = getLogger("activation-session-store");
 
 /**
  * Mark a conversation as an activation-rail session. Idempotent (the row's
- * primary key is the conversation id) and best-effort: a write failure is
- * logged and swallowed so it never blocks the turn that triggered it.
+ * primary key is the conversation id) and best-effort: an unavailable memory
+ * database or a write failure is logged and swallowed so it never blocks the
+ * turn that triggered it.
  */
 export function markActivationSession(conversationId: string): void {
   try {
-    getDb()
-      .insert(activationSessions)
-      .values({ conversationId, createdAt: Date.now() })
-      .onConflictDoNothing()
-      .run();
+    const raw = memorySqliteOrNull("markActivationSession");
+    if (!raw) {
+      return;
+    }
+    raw
+      .query(
+        /*sql*/ `INSERT OR IGNORE INTO activation_sessions (conversation_id, created_at) VALUES (?, ?)`,
+      )
+      .run(conversationId, Date.now());
   } catch (err) {
     log.warn({ err, conversationId }, "Failed to mark activation session");
   }
 }
 
 /**
- * Whether the given conversation was started on the activation rail. Best-effort:
- * a read failure is logged and treated as "not an activation session".
+ * Whether the given conversation was started on the activation rail.
+ * Best-effort: an unavailable memory database or a read failure is logged and
+ * treated as "not an activation session".
  */
 export function isActivationSession(conversationId: string): boolean {
   try {
-    const row = getDb()
-      .select({ conversationId: activationSessions.conversationId })
-      .from(activationSessions)
-      .where(eq(activationSessions.conversationId, conversationId))
-      .limit(1)
-      .get();
-    return row !== undefined;
+    const raw = memorySqliteOrNull("isActivationSession");
+    if (!raw) {
+      return false;
+    }
+    return (
+      raw
+        .query(
+          /*sql*/ `SELECT 1 FROM activation_sessions WHERE conversation_id = ?`,
+        )
+        .get(conversationId) != null
+    );
   } catch (err) {
     log.warn({ err, conversationId }, "Failed to read activation session");
     return false;

package/src/plugins/defaults/memory/context-search/sources/memory-v2.ts

@@ -24,10 +24,11 @@
 // still surface lexical hits, and vice versa.
 
 import { readdir, readFile, realpath, stat } from "node:fs/promises";
-import { extname, isAbsolute, join, relative } from "node:path";
+import { extname, join } from "node:path";
 
 import { embedWithRetry } from "../../../../../persistence/embeddings/embed.js";
 import { getLogger } from "../../logging.js";
+import { isPathInsideRoot } from "../../path-containment.js";
 import { spreadActivation } from "../../v2/activation.js";
 import { getEdgeIndex } from "../../v2/edge-index.js";
 import {
@@ -580,14 +581,6 @@ function normalizeExcerpt(excerpt: string): string {
   return excerpt.trim().replace(/\s+/g, " ").toLowerCase();
 }
 
-function isPathInsideRoot(pathToCheck: string, rootRealPath: string): boolean {
-  const pathRelativeToRoot = relative(rootRealPath, pathToCheck);
-  return (
-    pathRelativeToRoot === "" ||
-    (!pathRelativeToRoot.startsWith("..") && !isAbsolute(pathRelativeToRoot))
-  );
-}
-
 function truncateExcerpt(text: string, maxChars: number): string {
   if (text.length <= maxChars) return text;
   return `${text.slice(0, maxChars - 3).trimEnd()}...`;

package/src/plugins/defaults/memory/context-search/sources/workspace.ts

@@ -1,6 +1,7 @@
 import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { extname, isAbsolute, join, relative, sep } from "node:path";
 
+import { isPathInsideRoot } from "../../path-containment.js";
 import type {
   RecallEvidence,
   RecallSearchContext,
@@ -1208,14 +1209,6 @@ export function normalizeWorkspacePathLiteral(
   return withoutLineSuffix.split(sep).join("/");
 }
 
-function isPathInsideRoot(pathToCheck: string, rootRealPath: string): boolean {
-  const pathRelativeToRoot = relative(rootRealPath, pathToCheck);
-  return (
-    pathRelativeToRoot === "" ||
-    (!pathRelativeToRoot.startsWith("..") && !isAbsolute(pathRelativeToRoot))
-  );
-}
-
 function toWorkspaceRelativePath(
   rootRealPath: string,
   filePath: string,

package/src/plugins/defaults/memory/graph/retriever.test.ts

@@ -126,7 +126,7 @@ function makeCapabilityNode(content: string, capId: string): NewNode {
 describe("loadContextMemory — query/sparse vector surfacing", () => {
   beforeAll(async () => {
     await initializeDb();
-  });
+  }, 30_000);
 
   beforeEach(async () => {
     embedShouldThrow = false;
@@ -136,7 +136,7 @@ describe("loadContextMemory — query/sparse vector surfacing", () => {
     searchRouter = null;
     resetDbForTesting();
     await initializeDb();
-  });
+  }, 30_000);
 
   test("returns the dense queryVector when embedding succeeds", async () => {
     embedVector = [0.42, 0.5, 0.7];
@@ -179,7 +179,7 @@ describe("loadContextMemory — query/sparse vector surfacing", () => {
 describe("retrieveForTurn — query/sparse vector surfacing", () => {
   beforeAll(async () => {
     await initializeDb();
-  });
+  }, 30_000);
 
   beforeEach(async () => {
     embedShouldThrow = false;
@@ -189,7 +189,7 @@ describe("retrieveForTurn — query/sparse vector surfacing", () => {
     searchRouter = null;
     resetDbForTesting();
     await initializeDb();
-  });
+  }, 30_000);
 
   test("returns the dense queryVector when embedding succeeds", async () => {
     embedVector = [0.9, 0.8, 0.7];
@@ -312,7 +312,7 @@ describe("retrieveForTurn — topic-pivot recovery", () => {
 
   beforeAll(async () => {
     await initializeDb();
-  });
+  }, 30_000);
 
   beforeEach(() => {
     embedShouldThrow = false;
@@ -462,7 +462,7 @@ describe("loadContextMemory — dual-query capability ranking", () => {
 
   beforeAll(async () => {
     await initializeDb();
-  });
+  }, 30_000);
 
   beforeEach(() => {
     embedShouldThrow = false;