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

package/src/plugins/defaults/memory/v3/hot-set.test.ts

@@ -1,18 +1,23 @@
 /**
  * Tests for the frecency hot-set lane (`hot-set.ts`) and its config schema.
  *
- * `computeHotSet` takes the db handle directly (no module mocks needed):
- * each test seeds an in-memory SQLite db with `memory_v3_selections` rows
- * (via the real migration) and asserts the decayed-frequency ranking.
+ * `computeHotSet` reads `memory_v3_selections` over the dedicated memory
+ * connection: each test installs an in-memory SQLite db into the `memory`
+ * singleton slot (where the accessor resolves its connection), seeds it with
+ * selection rows, and asserts the decayed-frequency ranking.
  */
 
 import { Database } from "bun:sqlite";
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { MemoryV3ConfigSchema } from "../../../../config/schemas/memory-v3.js";
-import { migrateAddMemoryV3Selections } from "../../../../persistence/migrations/268-add-memory-v3-selections.js";
+import {
+  clearStoredDb,
+  setStoredDb,
+} from "../../../../persistence/db-singleton.js";
+import { ensureMemoryV3SelectionsSchema } from "../../../../persistence/migrations/338-move-memory-v3-selections-to-memory-db.js";
 import * as schema from "../../../../persistence/schema/index.js";
 import { computeHotSet, type HotSetOptions } from "./hot-set.js";
 
@@ -20,12 +25,15 @@ const HALF_LIFE_MS = 1000;
 const NOW = 100_000;
 
 let sqlite: Database;
-let db: ReturnType<typeof drizzle<typeof schema>>;
 
 beforeEach(() => {
   sqlite = new Database(":memory:");
-  db = drizzle(sqlite, { schema });
-  migrateAddMemoryV3Selections(db);
+  ensureMemoryV3SelectionsSchema(sqlite);
+  setStoredDb("memory", drizzle(sqlite, { schema }), () => sqlite.close());
+});
+
+afterEach(() => {
+  clearStoredDb("memory");
 });
 
 let nextTurn = 0;
@@ -40,16 +48,13 @@ function seed(slug: string, createdAts: number[]): void {
 }
 
 function hotSet(overrides: Partial<HotSetOptions> = {}) {
-  return computeHotSet(
-    { db },
-    {
-      k: 10,
-      halfLifeMs: HALF_LIFE_MS,
-      now: NOW,
-      excludeSlugs: new Set<string>(),
-      ...overrides,
-    },
-  );
+  return computeHotSet({
+    k: 10,
+    halfLifeMs: HALF_LIFE_MS,
+    now: NOW,
+    excludeSlugs: new Set<string>(),
+    ...overrides,
+  });
 }
 
 describe("computeHotSet", () => {
@@ -111,6 +116,19 @@ describe("computeHotSet", () => {
     seed("page-a", [NOW + 50 * HALF_LIFE_MS]);
     expect(hotSet()[0]!.score).toBeCloseTo(1, 10);
   });
+
+  test("degrades to an empty hot set when the memory database is unavailable", () => {
+    seed("page-a", [NOW]);
+    // Simulate unavailability through the singleton slot instead of
+    // `mock.module`, which is process-global and leaks into sibling test
+    // files. The accessor extracts the raw connection from the stored
+    // handle's `$client`, so a handle without one makes `getMemorySqlite()`
+    // resolve to null, the same contract computeHotSet sees when the
+    // dedicated open fails.
+    clearStoredDb("memory");
+    setStoredDb("memory", { $client: null }, () => {});
+    expect(hotSet()).toEqual([]);
+  });
 });
 
 describe("MemoryV3ConfigSchema hotSet", () => {

package/src/plugins/defaults/memory/v3/hot-set.ts

@@ -14,17 +14,9 @@
  * the hot lane never duplicates core.
  */
 
-import {
-  type DrizzleDb,
-  getSqliteFrom,
-} from "../../../../persistence/db-connection.js";
+import { memorySqliteOrNull } from "../memory-db.js";
 import type { Slug } from "./types.js";
 
-export interface HotSetDeps {
-  /** Handle to the database containing `memory_v3_selections`. */
-  db: DrizzleDb;
-}
-
 export interface HotSetOptions {
   /** Maximum number of slugs returned. */
   k: number;
@@ -52,15 +44,21 @@ interface SelectionAgeRow {
  * Deterministic for fixed inputs: ties break score desc, then slug asc. The
  * decay sum runs in TS over `(slug, created_at)` pairs — the selections table
  * is small enough that reading it directly beats pushing the math into SQL.
+ *
+ * Reads `memory_v3_selections` over the dedicated memory connection.
+ * Fail-soft: an unavailable memory database yields an empty hot set — the
+ * lane simply contributes nothing to the stable prefix.
  */
-export function computeHotSet(
-  deps: HotSetDeps,
-  opts: HotSetOptions,
-): HotSetEntry[] {
+export function computeHotSet(opts: HotSetOptions): HotSetEntry[] {
   const { k, halfLifeMs, now, excludeSlugs } = opts;
   if (k <= 0) return [];
 
-  const rows = getSqliteFrom(deps.db)
+  const raw = memorySqliteOrNull("computeHotSet");
+  if (!raw) {
+    return [];
+  }
+
+  const rows = raw
     .query(
       /*sql*/ `
       SELECT slug, created_at FROM memory_v3_selections

package/src/plugins/defaults/memory/v3/learned-edges.test.ts

@@ -1,18 +1,23 @@
 /**
  * Tests for the learned-edge lane (`learned-edges.ts`).
  *
- * `computeLearnedEdgeGraph` takes the db handle directly (no module mocks):
- * each test seeds an in-memory SQLite db with `memory_v3_selections` rows
- * (via the real migration) and asserts the NPMI association graph. Rows
+ * `computeLearnedEdgeGraph` reads `memory_v3_selections` over the dedicated
+ * memory connection: each test installs an in-memory SQLite db into the
+ * `memory` singleton slot (where the accessor resolves its connection), seeds
+ * it with selection rows, and asserts the NPMI association graph. Rows
  * sharing a `(conversation_id, created_at)` form one selector call.
  */
 
 import { Database } from "bun:sqlite";
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { migrateAddMemoryV3Selections } from "../../../../persistence/migrations/268-add-memory-v3-selections.js";
+import {
+  clearStoredDb,
+  setStoredDb,
+} from "../../../../persistence/db-singleton.js";
+import { ensureMemoryV3SelectionsSchema } from "../../../../persistence/migrations/338-move-memory-v3-selections-to-memory-db.js";
 import * as schema from "../../../../persistence/schema/index.js";
 import {
   computeLearnedEdgeGraph,
@@ -23,12 +28,15 @@ const HALF_LIFE_MS = 1_000_000;
 const NOW = 100_000;
 
 let sqlite: Database;
-let db: ReturnType<typeof drizzle<typeof schema>>;
 
 beforeEach(() => {
   sqlite = new Database(":memory:");
-  db = drizzle(sqlite, { schema });
-  migrateAddMemoryV3Selections(db);
+  ensureMemoryV3SelectionsSchema(sqlite);
+  setStoredDb("memory", drizzle(sqlite, { schema }), () => sqlite.close());
+});
+
+afterEach(() => {
+  clearStoredDb("memory");
 });
 
 let nextTurn = 0;
@@ -44,25 +52,22 @@ function seedCall(slugs: string[], createdAt = NOW, conv = "conv-1"): void {
 }
 
 function graphOf(overrides: Partial<LearnedEdgesOptions> = {}) {
-  return computeLearnedEdgeGraph(
-    { db },
-    {
-      halfLifeMs: HALF_LIFE_MS,
-      minCount: 2,
-      npmiFloor: 0.2,
-      maxPerPage: 6,
-      now: NOW,
-      windowMs: NOW,
-      knownSlugs: new Set([
-        "page-a",
-        "page-b",
-        "page-c",
-        "page-d",
-        "skills/widget",
-      ]),
-      ...overrides,
-    },
-  );
+  return computeLearnedEdgeGraph({
+    halfLifeMs: HALF_LIFE_MS,
+    minCount: 2,
+    npmiFloor: 0.2,
+    maxPerPage: 6,
+    now: NOW,
+    windowMs: NOW,
+    knownSlugs: new Set([
+      "page-a",
+      "page-b",
+      "page-c",
+      "page-d",
+      "skills/widget",
+    ]),
+    ...overrides,
+  });
 }
 
 const peersOf = (
@@ -180,4 +185,19 @@ describe("computeLearnedEdgeGraph", () => {
     const graph = graphOf({ windowMs: 10_000 });
     expect(graph.adjacency.size).toBe(0);
   });
+
+  test("degrades to an empty graph when the memory database is unavailable", () => {
+    // Simulate unavailability through the singleton slot instead of
+    // `mock.module`, which is process-global and leaks into sibling test
+    // files. The accessor extracts the raw connection from the stored
+    // handle's `$client`, so a handle without one makes `getMemorySqlite()`
+    // resolve to null, the same contract computeLearnedEdgeGraph sees when
+    // the dedicated open fails.
+    clearStoredDb("memory");
+    setStoredDb("memory", { $client: null }, () => {});
+
+    const graph = graphOf();
+    expect(graph.adjacency.size).toBe(0);
+    expect(graph.hubs.size).toBe(0);
+  });
 });

package/src/plugins/defaults/memory/v3/learned-edges.ts

@@ -38,18 +38,10 @@
  * the persistence; nothing else is stored.
  */
 
-import {
-  type DrizzleDb,
-  getSqliteFrom,
-} from "../../../../persistence/db-connection.js";
+import { memorySqliteOrNull } from "../memory-db.js";
 import type { EdgeGraph } from "./edge.js";
 import type { Slug } from "./types.js";
 
-export interface LearnedEdgesDeps {
-  /** Handle to the database containing `memory_v3_selections`. */
-  db: DrizzleDb;
-}
-
 export interface LearnedEdgesOptions {
   /** Decay half-life in milliseconds: a selector call this old contributes
    *  half the weight of one made now. */
@@ -86,11 +78,12 @@ interface SelectionRow {
  * Deterministic for fixed inputs: per-page neighbors order by NPMI desc, then
  * peer slug asc. Symmetric by construction — an edge contributes to BOTH
  * endpoints' neighbor lists (each independently subject to `maxPerPage`).
+ *
+ * Reads `memory_v3_selections` over the dedicated memory connection.
+ * Fail-soft: an unavailable memory database yields an empty graph — the lane
+ * simply surfaces no learned associations.
  */
-export function computeLearnedEdgeGraph(
-  deps: LearnedEdgesDeps,
-  opts: LearnedEdgesOptions,
-): EdgeGraph {
+export function computeLearnedEdgeGraph(opts: LearnedEdgesOptions): EdgeGraph {
   const { halfLifeMs, minCount, npmiFloor, maxPerPage, now, windowMs } = opts;
   const empty: EdgeGraph = {
     adjacency: new Map(),
@@ -99,7 +92,12 @@ export function computeLearnedEdgeGraph(
   };
   if (maxPerPage <= 0) return empty;
 
-  const rows = getSqliteFrom(deps.db)
+  const raw = memorySqliteOrNull("computeLearnedEdgeGraph");
+  if (!raw) {
+    return empty;
+  }
+
+  const rows = raw
     .query(
       /*sql*/ `
       SELECT conversation_id, slug, created_at FROM memory_v3_selections

package/src/plugins/defaults/memory/v3/orchestrate.ts

@@ -89,9 +89,18 @@ const log = getLogger("memory-v3-injection-gate");
 export const MEMORY_V3_INJECTION_GATE_CHECK_NAME = "memory_v3_injection_gate";
 
 /** Record one injection-gate run to usage telemetry. `detail` keys are the
- *  platform-side contract (snake_case, scores and reason codes only — never
- *  conversation content). Never throws: the gate is pass-open by design, and a
- *  telemetry failure must not cost the turn its memory either. */
+ *  platform-side contract (snake_case; scores, reason codes, and corpus-size
+ *  counts only — never page titles, slugs, or conversation content). Never
+ *  throws: the gate is pass-open by design, and a telemetry failure must not
+ *  cost the turn its memory either.
+ *
+ *  `detail.scored` says whether checkV3Gate actually weighed scores this run, as
+ *  opposed to the run taking a pass-open shortcut (dense off, dense unavailable,
+ *  gate threw). Pass rate is only meaningful over scored runs — the shortcuts are
+ *  all unconditional passes and would otherwise inflate it. It is derivable from
+ *  `reason`, but the daemon owns the reason set and adds to it freely, so it is
+ *  reported explicitly rather than left for the platform to re-derive from a
+ *  hardcoded list that would silently miscount the next reason we add. */
 function recordGateRun(detail: Record<string, unknown>): void {
   try {
     recordWatchdogEvent({
@@ -105,6 +114,35 @@ function recordGateRun(detail: Record<string, unknown>): void {
   }
 }
 
+/** `check_name` of the `watchdog` telemetry event recorded once per orchestrated
+ *  turn, carrying what the SELECTOR did. Keep this string stable — the platform's
+ *  memory admin analytics filter on it. */
+export const MEMORY_V3_SELECTION_CHECK_NAME = "memory_v3_selection";
+
+/** Record one turn's selection outcome. Deliberately a SEPARATE event from
+ *  {@link MEMORY_V3_INJECTION_GATE_CHECK_NAME} rather than extra keys on it: the
+ *  gate records at decision time, before selection has run, so folding the
+ *  outcome in would mean deferring the gate event until after `selectPool` — and
+ *  losing every gate run whenever selection throws, which is exactly the
+ *  incident we would want the gate telemetry for. This event carries
+ *  `gate_reason` so the two still group together without a join.
+ *
+ *  `value` is the selection count. Never throws, same as the gate counter. */
+function recordSelectionRun(
+  value: number,
+  detail: Record<string, unknown>,
+): void {
+  try {
+    recordWatchdogEvent({
+      checkName: MEMORY_V3_SELECTION_CHECK_NAME,
+      value,
+      detail,
+    });
+  } catch {
+    // Same contract as recordGateRun: telemetry must never cost a turn.
+  }
+}
+
 /** Default number of BM25 needle articles to fold into the pool. */
 export const DEFAULT_NEEDLE_K = 12;
 /** Default number of dense-lane articles to fold into the pool. */
@@ -182,6 +220,12 @@ export interface OrchestrateDeps {
    *  `enabled`, assembled in observeTurn). Omitted/disabled → the gate never
    *  runs and every turn proceeds to selectPool as before. */
   gateConfig?: V3GateConfig;
+  /** Real concept-page count at lane build — the same corpus-size signal
+   *  `resolveV3Tuning` switches the lean/full profile on. Reported with each
+   *  gate run so the reason distribution can be read against
+   *  `MEMORY_V3_FULL_PROFILE_MIN_PAGES`; omitted drops the field from the
+   *  telemetry detail (the gate itself never reads it). */
+  realConceptPageCount?: number;
 }
 
 /** A finder-lane candidate: the slug, the descriptor that justified it, and
@@ -430,29 +474,90 @@ export async function orchestrate(
   //
   // The gate is dense-gated: it only runs when the live dense lane produced hits
   // (`liveDensed.length > 0`). In healthy operation dense returns top-k hits for
-  // any query, so zero live dense hits means dense is unavailable — denseK=0 (the
-  // new-user/small-corpus profile), a degraded embedding backend, a Qdrant error
-  // (`denseLaneScored` swallows these to `[]`), or only stale deleted-page points
-  // returned — NOT low relevance. checkV3Gate reads only finder scores and cannot
-  // tell those apart, so without live dense signal we pass open rather than
-  // suppress all memory (not even the core/hot/fresh prefix) on every
-  // lexically-weak turn.
+  // any query, so zero live dense hits means dense is unavailable, NOT low
+  // relevance. checkV3Gate reads only finder scores and cannot tell those apart,
+  // so without live dense signal we pass open rather than suppress all memory
+  // (not even the core/hot/fresh prefix) on every lexically-weak turn.
+  //
+  // Two very different situations reach that pass-open, and they carry distinct
+  // reason codes because only one of them is a problem:
+  //   - dense_disabled:    `denseK === 0`, so the lane never ran. The lean
+  //                        new-user profile (`MEMORY_V3_NEW_USER_TUNING`) sets it
+  //                        for sub-threshold corpora, and that same profile sets
+  //                        `selectorEnabled: false` — so there is no selectPool
+  //                        call for the gate to save and passing open is free.
+  //                        Expected, benign, and the bulk of gate runs.
+  //   - dense_unavailable: the lane ran and yielded nothing live — a degraded
+  //                        embedding backend, a Qdrant error (`denseLaneScored`
+  //                        swallows these to `[]`), or only stale deleted-page
+  //                        points. Dense SHOULD have scored this turn and did
+  //                        not, so this one is worth alerting on.
+  //
+  // Every run carries the corpus size, so the reason mix can be read against the
+  // profile threshold rather than guessed at: `dense_disabled` is sub-threshold
+  // by construction, and whether those assistants sit at 1 page or 9 is the
+  // difference between "empty" and "about to cross".
+  const recordGate = (detail: Record<string, unknown>): void =>
+    recordGateRun(
+      deps.realConceptPageCount === undefined
+        ? detail
+        : { ...detail, real_concept_page_count: deps.realConceptPageCount },
+    );
+
+  // This turn's gate decision, carried to the selection event so the two group
+  // together without a join. Null when the gate never ran (disabled/omitted).
+  let gateOutcome: { reason: string; pass: boolean } | null = null;
+
+  // What the SELECTOR did with the pool the gate let through — the outcome the
+  // gate's own pass rate cannot see. A passed gate only means selectPool got to
+  // run; the selector is told to return `[]` when no candidate is relevant, so
+  // it is the real injection decision and the pass rate is an upper bound on it.
+  //
+  // `selector_ran` marks the turns where the selector actually JUDGED the pool,
+  // and is the filter that keeps a relevance rate honest. Three ways a turn can
+  // report zero selections without the selector having been asked, all of which
+  // must stay out of that rate:
+  //   - the lean profile sets `selectorEnabled: false`, so
+  //     `selectAllPoolCandidates` returns the whole pool untouched (would read
+  //     as a 100% hit rate),
+  //   - a closed gate hard-skips selection entirely (a 0%),
+  //   - the pool is empty, and `selectPool` returns `[]` before it ever reaches
+  //     the provider (also a 0%).
+  // The last is why `poolSize` decides this rather than each call site: an empty
+  // pool is not a judgment that nothing was relevant, and no caller has to
+  // remember that.
+  const recordSelection = (
+    selections: SelectedPage[],
+    poolSize: number,
+  ): void => {
+    const detail: Record<string, unknown> = {
+      gate_reason: gateOutcome?.reason ?? null,
+      gate_pass: gateOutcome?.pass ?? null,
+      selector_ran: deps.selectorEnabled !== false && poolSize > 0,
+      selected_count: selections.length,
+      pool_size: poolSize,
+    };
+    if (deps.realConceptPageCount !== undefined) {
+      detail.real_concept_page_count = deps.realConceptPageCount;
+    }
+    recordSelectionRun(selections.length, detail);
+  };
   if (deps.gateConfig?.enabled) {
     if (liveDensed.length === 0) {
-      // No live dense hits (denseK=0 / degraded backend / Qdrant error swallowed
-      // to [] / only stale deleted-page points returned). That means dense is
-      // unavailable, not low relevance, so pass open — but record it so rollout
-      // telemetry sees these turns instead of silently skipping the gate.
+      const reason = denseEnabled ? "dense_unavailable" : "dense_disabled";
       log.info(
         {
           conversationId: turn.conversationId,
           turnNumber: turn.turnNumber,
-          reason: "dense_unavailable",
+          reason,
           pass: true,
         },
-        "memory-v3 injection gate: dense lane unavailable, passing open",
+        denseEnabled
+          ? "memory-v3 injection gate: dense lane unavailable, passing open"
+          : "memory-v3 injection gate: dense lane disabled, passing open",
       );
-      recordGateRun({ pass: true, reason: "dense_unavailable" });
+      gateOutcome = { reason, pass: true };
+      recordGate({ pass: true, reason, scored: false });
     } else {
       let gate: V3GateResult | null = null;
       try {
@@ -469,7 +574,8 @@ export async function orchestrate(
           },
           "memory-v3 injection gate threw; passing open (proceeding with selection)",
         );
-        recordGateRun({ pass: true, reason: "gate_error" });
+        gateOutcome = { reason: "gate_error", pass: true };
+        recordGate({ pass: true, reason: "gate_error", scored: false });
       }
       if (gate) {
         log.info(
@@ -480,9 +586,11 @@ export async function orchestrate(
           },
           "memory-v3 injection gate decision",
         );
-        recordGateRun({
+        gateOutcome = { reason: gate.reason, pass: gate.pass };
+        recordGate({
           pass: gate.pass,
           reason: gate.reason,
+          scored: true,
           top_dense_score: gate.topDenseScore,
           top_norm_sparse_score: gate.topNormSparseScore,
           checked_articles: gate.checkedArticles,
@@ -505,10 +613,18 @@ export async function orchestrate(
             // explicitly configured with `selectorEnabled: false` AND
             // `denseK > 0` (the dense-gated gate only runs with dense hits; the
             // new-user profile sets `denseK: 0`, so the gate never runs for it).
-            return closed(
-              await runSelection({ stable: buildStable(), finder: [] }),
-            );
+            const stableOnly = buildStable();
+            const bypassed = await runSelection({
+              stable: stableOnly,
+              finder: [],
+            });
+            recordSelection(bypassed, stableOnly.length);
+            return closed(bypassed);
           }
+          // Hard skip: the selector is never consulted, so this is a zero
+          // selection BY CONSTRUCTION, not a judgment that nothing was relevant.
+          // `selector_ran: false` keeps it out of any relevance rate.
+          recordSelection([], 0);
           return closed([]);
         }
       }
@@ -602,6 +718,7 @@ export async function orchestrate(
   // scaffold; `undefined` falls through to the bundled default.
   const pool = { stable, finder: finderTail };
   const selections = await runSelection(pool);
+  recordSelection(selections, stable.length + finderTail.length);
 
   return {
     selections,

package/src/plugins/defaults/memory/v3/prune.test.ts

@@ -31,8 +31,8 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 import type { Message } from "@vellumai/plugin-api";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { migrateAddMemoryV3Selections } from "../../../../persistence/migrations/268-add-memory-v3-selections.js";
 import { migrateAddMemoryV3EverInjected } from "../../../../persistence/migrations/277-add-memory-v3-ever-injected.js";
+import { ensureMemoryV3SelectionsSchema } from "../../../../persistence/migrations/338-move-memory-v3-selections-to-memory-db.js";
 import * as schema from "../../../../persistence/schema/index.js";
 import { wrapMemoryBlock } from "../memory-marker.js";
 
@@ -48,12 +48,15 @@ let pruneConfig: {
 } | null = null;
 
 let testSqlite: Database;
+// `planPrune`'s recency ranking reads `memory_v3_selections` over the
+// dedicated memory connection, resolved via `getMemorySqlite` — stubbed to a
+// second in-memory DB carrying the relocated table's schema.
+let memorySqlite: Database;
 let testDb = makeDb();
 function makeDb() {
   testSqlite = new Database(":memory:");
   const db = drizzle(testSqlite, { schema });
   migrateAddMemoryV3EverInjected(db);
-  migrateAddMemoryV3Selections(db);
   // Minimal `messages` shape — `collectPersistedV3Cards` reads only
   // `conversation_id` and `metadata`.
   testSqlite.run(/*sql*/ `
@@ -66,6 +69,8 @@ function makeDb() {
       created_at INTEGER NOT NULL
     )
   `);
+  memorySqlite = new Database(":memory:");
+  ensureMemoryV3SelectionsSchema(memorySqlite);
   return db;
 }
 
@@ -76,6 +81,8 @@ mock.module("../../../../persistence/db-connection.js", () => ({
     pruneMockActive
       ? testSqlite
       : realDb.getSqliteFrom(db as Parameters<typeof realDb.getSqliteFrom>[0]),
+  getMemorySqlite: () =>
+    pruneMockActive ? memorySqlite : realDb.getMemorySqlite(),
 }));
 
 // Memory code resolves its config through the plugin's own accessor
@@ -120,7 +127,7 @@ function insertSelection(
   slug: string,
   createdAt: number,
 ): void {
-  testSqlite
+  memorySqlite
     .query(
       /*sql*/ `
       INSERT OR REPLACE INTO memory_v3_selections

package/src/plugins/defaults/memory/v3/prune.ts

@@ -63,6 +63,7 @@ import type { ContentBlock, Message } from "@vellumai/plugin-api";
 import { getDb, getSqliteFrom } from "../../../../persistence/db-connection.js";
 import { getMemoryConfig } from "../config.js";
 import { getLogger } from "../logging.js";
+import { memorySqliteOrNull } from "../memory-db.js";
 import { unwrapMemoryBlock, wrapMemoryBlock } from "../memory-marker.js";
 import {
   INJECTED_CONCEPT_HEADER_REGEX,
@@ -210,12 +211,14 @@ export interface PruneDeps {
  *
  * The footprint and the candidates both range over the ACTIVE injected slugs.
  * Candidates are ranked by last selection recency — `MAX(created_at)` per
- * slug from `memory_v3_selections`, falling back to the store's `injected_at`
- * for slugs with no selection rows (e.g. rows copied by a full fork) — taken
- * oldest-first until the footprint is at `targetResidentBytes`. Core/hot lane
- * members are exempt, and zero-byte rows (capability slugs, truncated-fork
- * seeds: dedup-only, no byte accounting) are skipped — pruning them frees
- * nothing while discarding inherited context.
+ * slug from `memory_v3_selections` (read over the dedicated memory
+ * connection; an unavailable memory database reads as no selection rows),
+ * falling back to the store's `injected_at` for slugs with no selection rows
+ * (e.g. rows copied by a full fork) — taken oldest-first until the footprint
+ * is at `targetResidentBytes`. Core/hot lane members are exempt, and
+ * zero-byte rows (capability slugs, truncated-fork seeds: dedup-only, no byte
+ * accounting) are skipped — pruning them frees nothing while discarding
+ * inherited context.
  */
 export function planPrune(
   deps: PruneDeps,
@@ -225,15 +228,18 @@ export function planPrune(
   const resident = activeEntries.reduce((sum, e) => sum + e.bytes, 0);
   if (resident <= deps.maxResidentBytes) return null;
 
-  const selectionRows = getSqliteFrom(getDb())
-    .query(
-      /*sql*/ `
+  const memoryRaw = memorySqliteOrNull("planPrune");
+  const selectionRows = memoryRaw
+    ? (memoryRaw
+        .query(
+          /*sql*/ `
       SELECT slug, MAX(created_at) AS lastSelectedAt FROM memory_v3_selections
       WHERE conversation_id = ?
       GROUP BY slug
     `,
-    )
-    .all(conversationId) as Array<{ slug: string; lastSelectedAt: number }>;
+        )
+        .all(conversationId) as Array<{ slug: string; lastSelectedAt: number }>)
+    : [];
   const lastSelectedAt = new Map(
     selectionRows.map((row) => [row.slug, row.lastSelectedAt]),
   );