@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/plugins/defaults/memory/v2/__tests__/injection-events.test.ts

@@ -1,41 +1,44 @@
 /**
- * Tests for `assistant/src/memory/v2/injection-events.ts` and its sibling
- * migration `256-memory-v2-injection-events.ts`.
+ * Tests for `assistant/src/plugins/defaults/memory/v2/injection-events.ts` and
+ * the main-DB migration `256-memory-v2-injection-events.ts`.
  *
  * Coverage matrix:
- *   - Migration creates the table + both indexes; safe to re-run.
+ *   - Migration 256 creates the main-side table + both indexes; safe to
+ *     re-run. (The table is subsequently relocated to the memory DB by
+ *     migration 326 — see table-relocation.test.ts for drain coverage.)
  *   - Backfill replays router-sourced concepts from memory_v2_activation_logs
  *     and is idempotent on a forced re-run with cleared checkpoint.
  *   - Backfill is a no-op when the activation-logs table doesn't exist
  *     (pre-234 DB).
- *   - recordInjectionEvents appends one row per slug per call; empty list
- *     is a no-op.
+ *   - recordInjectionEvents appends one row per slug per call to the memory
+ *     connection; empty list is a no-op.
  *   - computeInjectionScore matches the closed-form decay at known deltas
  *     (0d ≈ 1, 3d ≈ 0.5, 6d ≈ 0.25) and sums multiple events linearly.
  *   - computeInjectionScores returns the same per-slug values in batch and
  *     omits slugs with no events.
  *
- * Uses an in-memory bun:sqlite database — no real workspace DB.
+ * Uses in-memory bun:sqlite databases — the accessor tests install one into
+ * the `memory` singleton slot (where the accessors resolve their connection),
+ * the migration tests drive a plain main-DB handle. No real workspace DB.
  */
 
 import { Database } from "bun:sqlite";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
-
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 import type { DrizzleDb } from "../../../../../persistence/db-connection.js";
 import { getSqliteFrom } from "../../../../../persistence/db-connection.js";
+import {
+  clearStoredDb,
+  setStoredDb,
+} from "../../../../../persistence/db-singleton.js";
 import { migrateMemoryV2ActivationLogs } from "../../../../../persistence/migrations/234-memory-v2-activation-logs.js";
 import {
   downMemoryV2InjectionEvents,
   migrateMemoryV2InjectionEvents,
 } from "../../../../../persistence/migrations/256-memory-v2-injection-events.js";
+import { ensureInjectionEventsSchema } from "../../../../../persistence/migrations/326-move-injection-events-to-memory-db.js";
 import * as schema from "../../../../../persistence/schema/index.js";
 import {
   computeInjectionScore,
@@ -57,14 +60,25 @@ const CHECKPOINTS_DDL = /*sql*/ `
 
 let sqlite: Database;
 let database: DrizzleDb;
+let memorySqlite: Database;
 
 beforeEach(() => {
   sqlite = new Database(":memory:");
   database = drizzle(sqlite, { schema });
   getSqliteFrom(database).exec(CHECKPOINTS_DDL);
+
+  // The accessors resolve the dedicated memory connection through the
+  // `memory` singleton slot — install a fresh in-memory DB there with the
+  // relocated table's schema. `clearStoredDb` in afterEach runs the closer.
+  memorySqlite = new Database(":memory:");
+  ensureInjectionEventsSchema(memorySqlite);
+  setStoredDb("memory", drizzle(memorySqlite, { schema }), () =>
+    memorySqlite.close(),
+  );
 });
 
 afterEach(() => {
+  clearStoredDb("memory");
   sqlite.close();
 });
 
@@ -203,14 +217,10 @@ describe("migrateMemoryV2InjectionEvents", () => {
 });
 
 describe("recordInjectionEvents", () => {
-  beforeEach(() => {
-    migrateMemoryV2InjectionEvents(database);
-  });
-
   test("appends one row per slug at the same timestamp", () => {
     const t = 1_000_000;
-    recordInjectionEvents(database, ["alice", "bob", "alice"], t);
-    const rows = getSqliteFrom(database)
+    recordInjectionEvents(["alice", "bob", "alice"], t);
+    const rows = memorySqlite
       .query(
         `SELECT slug, injected_at FROM memory_v2_injection_events ORDER BY id`,
       )
@@ -222,9 +232,23 @@ describe("recordInjectionEvents", () => {
     ]);
   });
 
+  test("writes land in the memory connection, not the main DB handle", () => {
+    recordInjectionEvents(["alice"], 1_000_000);
+    const inMain = getSqliteFrom(database)
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_injection_events'`,
+      )
+      .get();
+    expect(inMain).toBeFalsy();
+    const { n } = memorySqlite
+      .query(`SELECT COUNT(*) as n FROM memory_v2_injection_events`)
+      .get() as { n: number };
+    expect(n).toBe(1);
+  });
+
   test("empty list is a no-op", () => {
-    recordInjectionEvents(database, [], 1_000_000);
-    const { n } = getSqliteFrom(database)
+    recordInjectionEvents([], 1_000_000);
+    const { n } = memorySqlite
       .query(`SELECT COUNT(*) as n FROM memory_v2_injection_events`)
       .get() as { n: number };
     expect(n).toBe(0);
@@ -232,87 +256,55 @@ describe("recordInjectionEvents", () => {
 });
 
 describe("computeInjectionScore", () => {
-  beforeEach(() => {
-    migrateMemoryV2InjectionEvents(database);
-  });
-
   test("returns 0 for a slug with no events", () => {
-    expect(computeInjectionScore(database, "missing", Date.now())).toBe(0);
+    expect(computeInjectionScore("missing", Date.now())).toBe(0);
   });
 
   test("single event 0 days ago → score ≈ 1", () => {
     const now = 10_000_000_000;
-    recordInjectionEvents(database, ["alice"], now);
-    expect(computeInjectionScore(database, "alice", now)).toBeCloseTo(1, 5);
+    recordInjectionEvents(["alice"], now);
+    expect(computeInjectionScore("alice", now)).toBeCloseTo(1, 5);
   });
 
   test("single event 3 days (one half-life) ago → score ≈ 0.5", () => {
     const now = 10_000_000_000;
-    recordInjectionEvents(
-      database,
-      ["alice"],
-      now - INJECTION_SCORE_HALF_LIFE_MS,
-    );
-    expect(computeInjectionScore(database, "alice", now)).toBeCloseTo(0.5, 5);
+    recordInjectionEvents(["alice"], now - INJECTION_SCORE_HALF_LIFE_MS);
+    expect(computeInjectionScore("alice", now)).toBeCloseTo(0.5, 5);
   });
 
   test("single event 6 days (two half-lives) ago → score ≈ 0.25", () => {
     const now = 10_000_000_000;
-    recordInjectionEvents(
-      database,
-      ["alice"],
-      now - 2 * INJECTION_SCORE_HALF_LIFE_MS,
-    );
-    expect(computeInjectionScore(database, "alice", now)).toBeCloseTo(0.25, 5);
+    recordInjectionEvents(["alice"], now - 2 * INJECTION_SCORE_HALF_LIFE_MS);
+    expect(computeInjectionScore("alice", now)).toBeCloseTo(0.25, 5);
   });
 
   test("multiple events sum independently", () => {
     const now = 10_000_000_000;
-    recordInjectionEvents(database, ["alice"], now);
-    recordInjectionEvents(
-      database,
-      ["alice"],
-      now - INJECTION_SCORE_HALF_LIFE_MS,
-    );
-    recordInjectionEvents(
-      database,
-      ["alice"],
-      now - 2 * INJECTION_SCORE_HALF_LIFE_MS,
-    );
-    expect(computeInjectionScore(database, "alice", now)).toBeCloseTo(1.75, 5);
+    recordInjectionEvents(["alice"], now);
+    recordInjectionEvents(["alice"], now - INJECTION_SCORE_HALF_LIFE_MS);
+    recordInjectionEvents(["alice"], now - 2 * INJECTION_SCORE_HALF_LIFE_MS);
+    expect(computeInjectionScore("alice", now)).toBeCloseTo(1.75, 5);
   });
 });
 
 describe("computeInjectionScores", () => {
-  beforeEach(() => {
-    migrateMemoryV2InjectionEvents(database);
-  });
-
   test("returns the same per-slug values as the single-slug helper", () => {
     const now = 10_000_000_000;
-    recordInjectionEvents(database, ["alice", "bob"], now);
-    recordInjectionEvents(
-      database,
-      ["alice"],
-      now - INJECTION_SCORE_HALF_LIFE_MS,
-    );
+    recordInjectionEvents(["alice", "bob"], now);
+    recordInjectionEvents(["alice"], now - INJECTION_SCORE_HALF_LIFE_MS);
 
-    const scores = computeInjectionScores(
-      database,
-      ["alice", "bob", "ghost"],
-      now,
-    );
+    const scores = computeInjectionScores(["alice", "bob", "ghost"], now);
     expect(scores.get("alice")).toBeCloseTo(1.5, 5);
     expect(scores.get("bob")).toBeCloseTo(1, 5);
     // ghost has no events — omitted from the result, not present as 0.
     expect(scores.has("ghost")).toBe(false);
     expect(scores.get("alice")).toBeCloseTo(
-      computeInjectionScore(database, "alice", now),
+      computeInjectionScore("alice", now),
       5,
     );
   });
 
   test("empty slug list returns empty map", () => {
-    expect(computeInjectionScores(database, [], Date.now()).size).toBe(0);
+    expect(computeInjectionScores([], Date.now()).size).toBe(0);
   });
 });

package/src/plugins/defaults/memory/v2/__tests__/injection.test.ts

@@ -43,31 +43,12 @@ import {
 import { drizzle } from "drizzle-orm/bun-sqlite";
 import { z } from "zod";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
 import type { AssistantConfig } from "../../../../../config/types.js";
 
 // ---------------------------------------------------------------------------
 // Module-level mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
-const STUB_QDRANT_CONFIG = {
-  memory: {
-    qdrant: {
-      url: "http://127.0.0.1:6333",
-      vectorSize: 384,
-      onDisk: true,
-    },
-  },
-};
-mock.module("../../../../../config/loader.js", () => ({
-  getConfig: () => STUB_QDRANT_CONFIG,
-  loadConfig: () => STUB_QDRANT_CONFIG,
-}));
-
 const realQdrantClient =
   await import("../../../../../persistence/embeddings/qdrant-client.js");
 mock.module("../../../../../persistence/embeddings/qdrant-client.js", () => ({

package/src/plugins/defaults/memory/v2/__tests__/migration.test.ts

@@ -31,22 +31,16 @@ import type {
   SendMessageOptions,
 } from "@vellumai/plugin-api";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
-
 // -- Mocks that must be installed before importing the module under test ---
 //
 // Order matters: every `mock.module` here runs before the migration module is
 // imported below, so its top-level `getLogger`/`getConfiguredProvider`/
 // `enqueueMemoryJob` references resolve to our stubs. Reversing the order
 // lets the real implementations leak through.
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
-// `runMemoryV2Migration` calls `enqueueMemoryJob` which in turn calls
-// `getDb()`. We intercept the enqueue call so the test doesn't need to wire
-// up the full migration runner / data-dir scaffolding just to count
-// enqueues. The stub records every (type, payload) pair for assertion.
+// `runMemoryV2Migration` enqueues jobs, which in turn touches the live DB.
+// We intercept the enqueue calls so the test doesn't need to wire up the
+// full migration runner / data-dir scaffolding just to count enqueues. The
+// stubs record every (type, payload) pair for assertion.
 const enqueuedJobs: Array<{ type: string; payload: Record<string, unknown> }> =
   [];
 mock.module("../../../../../persistence/jobs-store.js", () => ({
@@ -54,6 +48,13 @@ mock.module("../../../../../persistence/jobs-store.js", () => ({
     enqueuedJobs.push({ type, payload });
     return `job-${enqueuedJobs.length}`;
   },
+  upsertEmbedConceptPageJob: (payload: { slug: string }) => {
+    enqueuedJobs.push({
+      type: "embed_concept_page",
+      payload: { slug: payload.slug },
+    });
+    return `job-${enqueuedJobs.length}`;
+  },
 }));
 
 // `getConfiguredProvider` is invoked when the runner is called without an

package/src/plugins/defaults/memory/v2/__tests__/page-index.test.ts

@@ -13,7 +13,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
 import type { ConceptPage, SkillEntry } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -25,10 +24,6 @@ import type { ConceptPage, SkillEntry } from "../types.js";
 const skillState: { entries: SkillEntry[] } = { entries: [] };
 const failingSlugs = new Set<string>();
 
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 mock.module("../skill-store.js", () => ({
   SKILL_SLUG_PREFIX: "skills/",
   listSkillEntries: () => skillState.entries,

package/src/plugins/defaults/memory/v2/__tests__/qdrant.test.ts

@@ -3,8 +3,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
-
 // Per-suite tmp data dir so the reembed sentinel never lands in the
 // developer's real ~/.vellum workspace.
 const TEST_DATA_DIR = mkdtempSync(join(tmpdir(), "memory-v2-qdrant-test-"));
@@ -13,31 +11,17 @@ const REEMBED_SENTINEL_PATH = join(
   ".memory-v2-reembed-required",
 );
 
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
+// Point the data dir (reembed sentinel) and workspace dir at the per-suite
+// tmp dir. Spread the real module so the config loader's own platform reads
+// (config path, quarantine notice) keep resolving against the seeded
+// workspace once the loader is real.
+const realPlatform = await import("../../../../../util/platform.js");
 mock.module("../../../../../util/platform.js", () => ({
+  ...realPlatform,
   getDataDir: () => TEST_DATA_DIR,
-  // Bun shares mocked modules across test files; some peer tests import
-  // `getWorkspaceDir` from this same module, so re-export it here to avoid
-  // an `undefined` if this mock is the one that wins evaluation order.
   getWorkspaceDir: () => TEST_DATA_DIR,
 }));
 
-// Stub getConfig — only the qdrant.url / vectorSize / onDisk fields matter.
-mock.module("../../../../../config/loader.js", () => ({
-  getConfig: () => ({
-    memory: {
-      qdrant: {
-        url: "http://127.0.0.1:6333",
-        vectorSize: 384,
-        onDisk: true,
-      },
-    },
-  }),
-}));
-
 mock.module("../../../../../persistence/embeddings/qdrant-client.js", () => ({
   resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));

package/src/plugins/defaults/memory/v2/__tests__/reranker.test.ts

@@ -8,15 +8,13 @@
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
 import type { AssistantConfig } from "../../../../../config/types.js";
 
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 mock.module("../../../../../util/platform.js", () => ({
   getWorkspaceDir: () => "/tmp/test-workspace",
+  // Imported by the real util/logger.js; ESM named-import validation
+  // requires it even though the silent test logger never calls it.
+  getLogsDir: () => "/tmp/test-workspace/logs",
 }));
 
 const backendState = {

package/src/plugins/defaults/memory/v2/__tests__/router.test.ts

@@ -74,13 +74,12 @@ mock.module("../skill-store.js", () => ({
 }));
 
 // Stub `computeInjectionScores` so tier-2 tests can dictate scores
-// without spinning up a real bun:sqlite db. Real production wiring is
-// covered by the splitTier2 unit tests in page-index.test.ts and the
-// score-formula tests in injection-events.test.ts.
+// without spinning up a real bun:sqlite db in the memory singleton slot.
+// Real production wiring is covered by the splitTier2 unit tests in
+// page-index.test.ts and the score-formula tests in injection-events.test.ts.
 const scoresStub = new Map<string, number>();
 mock.module("../injection-events.js", () => ({
   computeInjectionScores: (
-    _db: unknown,
     slugs: readonly string[],
     _now: number,
   ): Map<string, number> => {
@@ -956,10 +955,6 @@ describe("runRouter — tier 1 (recently modified)", () => {
 // ---------------------------------------------------------------------------
 
 describe("runRouter — tier 2 (highest EMA)", () => {
-  // Any non-null value passes the `params.database` check in the orchestrator;
-  // the real db is never touched because computeInjectionScores is mocked.
-  const stubDb = {} as Parameters<typeof runRouter>[0]["database"];
-
   beforeEach(async () => {
     await writePage(workspaceDir, makePage("alpha", { summary: "A" }));
     await writePage(workspaceDir, makePage("bravo", { summary: "B" }));
@@ -974,7 +969,6 @@ describe("runRouter — tier 2 (highest EMA)", () => {
       workspaceDir,
       ...COMMON_PARAMS,
       config: makeConfig(),
-      database: stubDb,
     });
     expect(providerCalls).toHaveLength(1);
   });
@@ -989,7 +983,6 @@ describe("runRouter — tier 2 (highest EMA)", () => {
       workspaceDir,
       ...COMMON_PARAMS,
       config: makeConfig({ tier2Size: 2 }),
-      database: stubDb,
     });
     expect(providerCalls.length).toBe(2);
 
@@ -1025,7 +1018,6 @@ describe("runRouter — tier 2 (highest EMA)", () => {
       workspaceDir,
       ...COMMON_PARAMS,
       config: makeConfig({ tier1Size: 2, tier2Size: 2 }),
-      database: stubDb,
     });
     expect(providerCalls.length).toBe(3);
 
@@ -1054,7 +1046,6 @@ describe("runRouter — tier 2 (highest EMA)", () => {
       workspaceDir,
       ...COMMON_PARAMS,
       config: makeConfig({ tier2Size: 100 }),
-      database: stubDb,
     });
     expect(providerCalls.length).toBe(2);
     const tier2Prompt = providerCalls[0].systemPrompt ?? "";
@@ -1071,7 +1062,6 @@ describe("runRouter — tier 2 (highest EMA)", () => {
       workspaceDir,
       ...COMMON_PARAMS,
       config: makeConfig({ tier1Size: 1, tier2Size: 1 }),
-      database: stubDb,
     });
 
     // Every selected slug should have a tier tag — exactly one of:
@@ -1092,20 +1082,17 @@ describe("runRouter — tier 2 (highest EMA)", () => {
     expect(tags.has("tier2")).toBe(true);
   });
 
-  test("tier2_size set without database logs a warn and skips tier 2", async () => {
-    scoresStub.set("bravo", 5.0);
+  test("tier2_size set with all-zero scores skips tier 2 (degraded memory DB)", async () => {
+    // No scores stubbed — mirrors `computeInjectionScores` returning an
+    // empty map when the memory connection is unavailable. Tier 2 must
+    // select nothing rather than pulling in arbitrary pages.
     providerStub = makeProvider(toolUseResponse([1]));
     await runRouter({
       workspaceDir,
       ...COMMON_PARAMS,
       config: makeConfig({ tier2Size: 2 }),
-      // No database → tier 2 silently skipped.
     });
     expect(providerCalls).toHaveLength(1);
-    const warned = warnLogs.some((l) =>
-      JSON.stringify(l.args).includes("tier2_size set but no database"),
-    );
-    expect(warned).toBe(true);
   });
 });
 

package/src/plugins/defaults/memory/v2/__tests__/sim.test.ts

@@ -17,36 +17,12 @@
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
 import type { AssistantConfig } from "../../../../../config/types.js";
 
 // ---------------------------------------------------------------------------
 // Module-level mocks (registered before `await import("../sim.js")`).
 // ---------------------------------------------------------------------------
 
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
-// Stub both `getConfig` and `loadConfig`. `loadConfig` is reached by code
-// paths transitively imported during teardown (e.g. dynamic imports inside
-// `oauth2.ts`); leaving it undefined here would break sibling test files
-// run in the same Bun process because `mock.module` replacements persist
-// across files.
-const STUB_QDRANT_CONFIG = {
-  memory: {
-    qdrant: {
-      url: "http://127.0.0.1:6333",
-      vectorSize: 384,
-      onDisk: true,
-    },
-  },
-};
-mock.module("../../../../../config/loader.js", () => ({
-  getConfig: () => STUB_QDRANT_CONFIG,
-  loadConfig: () => STUB_QDRANT_CONFIG,
-}));
-
 // Same partial-mock pattern as for the embedding backend: re-export the
 // real symbols and override only `resolveQdrantUrl` so the v2 qdrant
 // client picks up our test URL.

package/src/plugins/defaults/memory/v2/__tests__/skill-content.test.ts

@@ -2,8 +2,9 @@
  * Tests for `memory/v2/skill-content.ts` — v2-owned port of v1's
  * `buildSkillContent` plus the `mcp-setup` description augmentation.
  */
-import { describe, expect, mock, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
+import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
 import type { SkillCapabilityInput } from "../skill-content.js";
 
 describe("buildSkillContent", () => {
@@ -89,17 +90,22 @@ describe("augmentMcpSetupDescription", () => {
   });
 
   test("appends 'Configured: <names>' for mcp-setup with enabled servers", async () => {
-    mock.module("../../../../../config/loader.js", () => ({
-      getConfig: () => ({
-        mcp: {
-          servers: {
-            "example-server": { enabled: true },
-            "another-server": { enabled: true },
-            "disabled-server": { enabled: false },
-          },
+    setConfig("mcp", {
+      servers: {
+        "example-server": {
+          transport: { type: "stdio", command: "example-cmd" },
+          enabled: true,
         },
-      }),
-    }));
+        "another-server": {
+          transport: { type: "stdio", command: "another-cmd" },
+          enabled: true,
+        },
+        "disabled-server": {
+          transport: { type: "stdio", command: "disabled-cmd" },
+          enabled: false,
+        },
+      },
+    });
     const { augmentMcpSetupDescription } = await import("../skill-content.js");
     const input: SkillCapabilityInput = {
       id: "mcp-setup",

package/src/plugins/defaults/memory/v2/__tests__/skill-store.test.ts

@@ -25,15 +25,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
 import type { ResolvedSkill } from "../../../../../config/skill-state.js";
 import type { SkillSummary } from "../../../../../config/skills.js";
 import type { CatalogSkill } from "../../../../../skills/catalog-install.js";
 
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 // ---------------------------------------------------------------------------
 // Programmable test state — drives every mocked dependency below.
 // ---------------------------------------------------------------------------
@@ -94,17 +89,6 @@ const state: TestState = {
   callSequence: [],
 };
 
-// Stub config so resolveSkillStates / mcp augmentation have something to read.
-mock.module("../../../../../config/loader.js", () => ({
-  getConfig: () => ({
-    memory: {
-      qdrant: { url: "http://127.0.0.1:6333", vectorSize: 3, onDisk: false },
-    },
-    mcp: { servers: {} },
-    skills: { entries: {}, allowBundled: [] },
-  }),
-}));
-
 mock.module("../../../../../config/skills.js", () => ({
   loadSkillCatalog: () => state.catalog ?? [],
 }));

package/src/plugins/defaults/memory/v2/__tests__/static-context.test.ts

@@ -34,16 +34,6 @@ mock.module("../../../../../util/logger.js", () => ({
 let configMemoryV2Enabled = true;
 let configMemoryEnabled = true;
 
-mock.module("../../../../../config/loader.js", () => ({
-  getConfig: () => ({}),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
 // static-context reads its gates through the plugin's own config accessor.
 mock.module("../../config.js", () => ({
   getMemoryConfig: () => ({

package/src/plugins/defaults/memory/v2/__tests__/sweep-job.test.ts

@@ -40,12 +40,6 @@ import type {
   SendMessageOptions,
 } from "@vellumai/plugin-api";
 
-import { makeMockLogger } from "../../../../../__tests__/helpers/mock-logger.js";
-
-mock.module("../../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 // Provider stub. Each test sets `providerStub` to control the response;
 // `null` simulates "no configured provider".
 let providerStub: Provider | null = null;

package/src/plugins/defaults/memory/v2/backfill-jobs.ts

@@ -97,9 +97,12 @@ export async function memoryV2MigrateJob(
 
 /**
  * Job handler: enqueue an `embed_concept_page` job per concept-page slug.
+ * Each enqueue coalesces with an already-pending job for the same slug, so
+ * stacked reembed runs converge on at most one pending embed per page.
  *
- * Returns the total number of jobs enqueued. Callers (and tests) use the
- * return value to assert progress without inspecting the job table directly.
+ * Returns the number of pages fanned out (enqueue attempts, not necessarily
+ * fresh rows). Callers (and tests) use the return value to assert progress
+ * without inspecting the job table directly.
  *
  * Note on meta files: `essentials.md` / `threads.md` / `recent.md` /
  * `buffer.md` are direct-injected into the system prompt every turn via