@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/consolidation-job.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/consolidation-job.ts`.
+ * Tests for `substrate/consolidation-job.ts`.
  *
  * Coverage matrix:
  *   - Flag off → no runner call; returns disabled.
@@ -73,7 +73,7 @@ let runnerImpl: () => Promise<{
   skipReason?: string;
 }> = runnerTrimsBuffer;
 
-mock.module("../../../../../../runtime/background-job-runner.js", () => ({
+mock.module("../../../../../runtime/background-job-runner.js", () => ({
   runBackgroundJob: async (opts: Record<string, unknown>) => {
     runnerCalls += 1;
     runnerLastArgs = opts;
@@ -90,7 +90,7 @@ mock.module("../../../../../../runtime/background-job-runner.js", () => ({
 // emitting a signal as a result of consolidation failure.
 const emitCalls: Array<Record<string, unknown>> = [];
 
-mock.module("../../../../../../notifications/emit-signal.js", () => ({
+mock.module("../../../../../notifications/emit-signal.js", () => ({
   emitNotificationSignal: async (params: Record<string, unknown>) => {
     emitCalls.push(params);
     return {
@@ -113,7 +113,7 @@ let nextJobIdCounter = 0;
 // enqueue-coalescing branch (`hasPendingJobOfType`).
 let pendingJobTypes = new Set<string>();
 
-mock.module("../../../../../../persistence/jobs-store.js", () => ({
+mock.module("../../../../../persistence/jobs-store.js", () => ({
   enqueueMemoryJob: (
     type: string,
     payload: Record<string, unknown>,
@@ -133,7 +133,7 @@ mock.module("../../../../../../persistence/jobs-store.js", () => ({
 // can assert what the handler wrote without initializing sqlite.
 const checkpointStore = new Map<string, string>();
 
-mock.module("../../../../../../persistence/checkpoints.js", () => ({
+mock.module("../../../../../persistence/checkpoints.js", () => ({
   getMemoryCheckpoint: (key: string): string | null =>
     checkpointStore.get(key) ?? null,
   setMemoryCheckpoint: (key: string, value: string): void => {
@@ -153,15 +153,17 @@ mock.module("../../../../../../persistence/checkpoints.js", () => ({
 // for the article-shape tests.
 let v3FlagOn = false;
 let flagStates: Record<string, boolean> = {};
-mock.module("../../../../../../config/assistant-feature-flags.js", () => ({
+mock.module("../../../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) => flagStates[key] ?? v3FlagOn,
 }));
 
 // The v3-live gate lives in config (`config.memory.v3.live`), read via
 // `isMemoryV3Live`; drive it through `flagStates["memory-v3-live"]` (and
 // `v3FlagOn` for the existing on/off tests).
-mock.module("../../../../../../config/memory-v3-gate.js", () => ({
+mock.module("../../../../../config/memory-v3-gate.js", () => ({
   isMemoryV3Live: () => flagStates["memory-v3-live"] ?? v3FlagOn,
+  isMemoryEnabled: (config?: { memory?: { enabled?: boolean } }) =>
+    config?.memory?.enabled !== false,
   usesConceptPageMemory: (memory?: {
     enabled?: boolean;
     v2?: { enabled?: boolean };
@@ -299,7 +301,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     );
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(outcome.cutoff).toBe("Apr 27, 9:03 AM");
     expect(outcome.deferredEntries).toBe(2);
     expect(runnerCalls).toBe(1);
@@ -315,7 +319,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     );
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(outcome.deferredEntries).toBe(0);
     // Cutoff is the run-start timestamp, not any buffer entry's.
     expect(outcome.cutoff).not.toBe("Apr 27, 9:03 AM");
@@ -330,7 +336,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     );
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(outcome.deferredEntries).toBe(0);
   });
 
@@ -340,7 +348,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     const outcome = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(outcome.deferredEntries).toBe(0);
   });
 
@@ -361,7 +371,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     return memoryV2ConsolidateJob(makeJob(), configWithMaxEntries(2)).then(
       (outcome) => {
         expect(outcome.kind).toBe("invoked");
-        if (outcome.kind !== "invoked") throw new Error("unreachable");
+        if (outcome.kind !== "invoked") {
+          throw new Error("unreachable");
+        }
         expect(outcome.deferredEntries).toBe(0);
         expect(outcome.cutoff).not.toBe("Apr 27, 9:00 AM");
       },
@@ -389,7 +401,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     );
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(outcome.cutoff).toBe("Apr 27, 9:03 AM");
     expect(outcome.deferredEntries).toBe(1);
   });
@@ -414,7 +428,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     );
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     // Two real entries, cap 2 → no chunking, full-buffer cutoff.
     expect(outcome.deferredEntries).toBe(0);
     expect(outcome.cutoff).not.toBe(" ");
@@ -438,7 +454,9 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     );
 
     expect(outcome.kind).toBe("invoked");
-    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    if (outcome.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(outcome.deferredEntries).toBe(0);
     expect(outcome.cutoff).not.toBe("Apr 27, 9:01 AM");
   });
@@ -763,7 +781,9 @@ describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", (
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") throw new Error("unreachable");
+    if (result.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(result.noProgress).toBe(false);
     expect(result.followUpJobIds).toEqual(["job-1"]);
     expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
@@ -781,7 +801,9 @@ describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", (
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") throw new Error("unreachable");
+    if (result.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(result.noProgress).toBe(false);
     expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
   });
@@ -795,7 +817,9 @@ describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", (
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") throw new Error("unreachable");
+    if (result.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(result.noProgress).toBe(true);
     expect(result.followUpJobIds).toEqual([]);
     expect(enqueuedJobs).toHaveLength(0);
@@ -815,7 +839,9 @@ describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", (
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") throw new Error("unreachable");
+    if (result.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(result.noProgress).toBe(true);
     expect(result.followUpJobIds).toEqual([]);
     expect(enqueuedJobs).toHaveLength(0);
@@ -828,7 +854,9 @@ describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", (
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") throw new Error("unreachable");
+    if (result.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v3_maintain"]);
     expect(result.followUpJobIds).toHaveLength(1);
   });
@@ -841,7 +869,9 @@ describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", (
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") throw new Error("unreachable");
+    if (result.kind !== "invoked") {
+      throw new Error("unreachable");
+    }
     // Dedup is not no-progress: the run drained the buffer; the follow-ups
     // are simply already covered by pending rows.
     expect(result.noProgress).toBe(false);

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/edge-index.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `memory/v2/edge-index.ts` — the in-memory directed edge index
+ * Tests for `substrate/edge-index.ts` — the in-memory directed edge index
  * derived from concept-page frontmatter.
  *
  * Tests live in temp workspaces (mkdtemp) and never touch `~/.vellum/`.

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/frontmatter-sweep.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/frontmatter-sweep.ts`.
+ * Tests for `substrate/frontmatter-sweep.ts`.
  *
  * Coverage:
  *   - v2 disabled → returns early, no warns, no throw.
@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { AssistantConfig } from "../../../../../../config/schema.js";
+import type { AssistantConfig } from "../../../../../config/schema.js";
 
 const warnCalls: Array<{ data: Record<string, unknown>; msg: string }> = [];
 const recordingLogger = {
@@ -29,7 +29,7 @@ const recordingLogger = {
   child: () => recordingLogger,
 };
 
-mock.module("../../../../../../util/logger.js", () => ({
+mock.module("../../../../../util/logger.js", () => ({
   getLogger: () => recordingLogger,
 }));
 

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/page-index.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `memory/v2/page-index.ts` — the router-prompt page index built
+ * Tests for `substrate/page-index.ts` — the router-prompt page index built
  * from concept pages plus seeded skill entries.
  *
  * Tests live in temp workspaces (`mkdtemp`) and never touch `~/.vellum/`. The

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/page-store.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/page-store.ts`.
+ * Tests for `substrate/page-store.ts`.
  *
  * Coverage matrix:
  *   - slugify: lowercase / kebab-case / ascii / 80-char cap / empty fallback.

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/prompts-consolidation.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/prompts/consolidation.ts` —
+ * Tests for `substrate/prompts/consolidation.ts` —
  * specifically `resolveConsolidationPrompt` which loads an optional
  * file-based override and falls back to the bundled prompt when the
  * override is missing/empty/unreadable.
@@ -38,7 +38,7 @@ const recordingLogger = {
   child: () => recordingLogger,
 };
 
-mock.module("../../../../../../util/logger.js", () => ({
+mock.module("../../../../../util/logger.js", () => ({
   getLogger: () => recordingLogger,
 }));
 

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/qdrant.test.ts

@@ -15,19 +15,16 @@ const REEMBED_SENTINEL_PATH = join(
 // 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", () => ({
+const realPlatform = await import("../../../../../util/platform.js");
+mock.module("../../../../../util/platform.js", () => ({
   ...realPlatform,
   getDataDir: () => TEST_DATA_DIR,
   getWorkspaceDir: () => TEST_DATA_DIR,
 }));
 
-mock.module(
-  "../../../../../../persistence/embeddings/qdrant-client.js",
-  () => ({
-    resolveQdrantUrl: () => "http://127.0.0.1:6333",
-  }),
-);
+mock.module("../../../../../persistence/embeddings/qdrant-client.js", () => ({
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
 
 // Mock the underlying @qdrant/js-client-rest package. The mock client
 // records every call and lets each test program the next response.
@@ -125,13 +122,17 @@ class MockQdrantClient {
   }
   async getCollection(_name: string) {
     state.getCollectionCalls++;
-    if (state.getCollectionThrows) throw state.getCollectionThrows;
+    if (state.getCollectionThrows) {
+      throw state.getCollectionThrows;
+    }
     return state.getCollectionInfo;
   }
   async createCollection(_name: string, params: unknown) {
     state.createCollectionCalls++;
     state.createCollectionParams = params;
-    if (state.createCollectionThrows) throw state.createCollectionThrows;
+    if (state.createCollectionThrows) {
+      throw state.createCollectionThrows;
+    }
     state.collectionExistsBeforeCreate = true;
     state.getCollectionInfo = FULL_SCHEMA_INFO;
     return {};
@@ -143,12 +144,16 @@ class MockQdrantClient {
   }
   async updateCollection(name: string, params: unknown) {
     state.updateCollectionCalls.push({ name, params });
-    if (state.updateCollectionThrows) throw state.updateCollectionThrows;
+    if (state.updateCollectionThrows) {
+      throw state.updateCollectionThrows;
+    }
     return {};
   }
   async count(_name: string, _opts: { exact: boolean }) {
     state.countCalls++;
-    if (state.countThrows) throw state.countThrows;
+    if (state.countThrows) {
+      throw state.countThrows;
+    }
     return { count: state.countResult };
   }
   async createPayloadIndex(
@@ -158,14 +163,18 @@ class MockQdrantClient {
     state.createIndexCalls.push(params);
     if (state.createIndexThrowQueue.length > 0) {
       const next = state.createIndexThrowQueue.shift();
-      if (next) throw next;
+      if (next) {
+        throw next;
+      }
     }
     return {};
   }
   async upsert(_name: string, params: { wait: boolean; points: MockPoint[] }) {
     if (state.upsertThrowQueue.length > 0) {
       const next = state.upsertThrowQueue.shift();
-      if (next) throw next;
+      if (next) {
+        throw next;
+      }
     }
     state.upsertCalls.push(params);
     return {};

package/src/plugins/defaults/memory/substrate/__tests__/reembed-job.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Tests for `assistant/src/plugins/defaults/memory/substrate/reembed-job.ts`.
+ *
+ * The handler is exercised with the heavy collaborators (embedding backend,
+ * Qdrant client) mocked at the module level so the suite never starts a real
+ * Qdrant/embedding backend.
+ *
+ * Coverage: the fan-out enqueues `N` jobs, one per concept-page slug; stacked
+ * runs coalesce to one pending job per slug; reserved meta-file slugs are
+ * never enqueued.
+ *
+ * Tests use temp workspaces (mkdtemp) — never `~/.vellum/`. Sample content
+ * uses generic placeholders (Alice, Bob, user@example.com).
+ */
+
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module-level mocks (registered before importing the module under test).
+// ---------------------------------------------------------------------------
+
+// Embedding backend — pulled in transitively through the enqueue helper's
+// module (`jobs/embed-concept-page.ts` also hosts the embed handler). Stub it
+// so the suite runs without an embedding backend.
+mock.module(
+  "../../../../../persistence/embeddings/embedding-backend.js",
+  () => ({
+    isEmbeddingDimensionAvailable: async () => true,
+    embedWithBackend: async () => ({
+      provider: "local",
+      model: "test-model",
+      vectors: [[0.1, 0.2, 0.3]],
+    }),
+    generateSparseEmbedding: () => ({
+      indices: [1, 2, 3],
+      values: [0.5, 0.5, 0.5],
+    }),
+    getMemoryBackendStatus: async () => ({
+      enabled: true,
+      degraded: false,
+      provider: "local",
+      model: "test-model",
+      reason: null,
+    }),
+    selectedBackendSupportsMultimodal: async () => false,
+  }),
+);
+
+// Qdrant client — stubbed so nothing in the transitive import graph can reach
+// a real Qdrant instance.
+class StubQdrantClient {
+  constructor(_opts: unknown) {}
+  async collectionExists(_name: string) {
+    return { exists: true };
+  }
+  async createCollection() {
+    return {};
+  }
+  async createPayloadIndex() {
+    return {};
+  }
+  async query() {
+    return { points: [] };
+  }
+}
+
+mock.module("@qdrant/js-client-rest", () => ({
+  QdrantClient: StubQdrantClient,
+}));
+
+const realQdrantClient =
+  await import("../../../../../persistence/embeddings/qdrant-client.js");
+mock.module("../../../../../persistence/embeddings/qdrant-client.js", () => ({
+  ...realQdrantClient,
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
+
+// ---------------------------------------------------------------------------
+// Workspace + DB setup. Imports are deferred to after env is set so any
+// internal `getWorkspaceDir()` resolves to the tmpdir.
+// ---------------------------------------------------------------------------
+
+let tmpWorkspace: string;
+let previousWorkspaceEnv: string | undefined;
+
+beforeAll(() => {
+  tmpWorkspace = mkdtempSync(join(tmpdir(), "memory-substrate-reembed-test-"));
+  mkdirSync(join(tmpWorkspace, "memory", "concepts"), { recursive: true });
+  previousWorkspaceEnv = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = tmpWorkspace;
+});
+
+afterAll(() => {
+  if (previousWorkspaceEnv === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceEnv;
+  }
+  rmSync(tmpWorkspace, { recursive: true, force: true });
+});
+
+const { getMemoryDb, getMemorySqlite } =
+  await import("../../../../../persistence/db-connection.js");
+const { resetDbForTesting } =
+  await import("../../../../../__tests__/db-test-helpers.js");
+const { initializeDb } = await import("../../../../../persistence/db-init.js");
+const { memoryJobs } =
+  await import("../../../../../persistence/schema/index.js");
+const { writePage } = await import("../page-store.js");
+const { memoryV2ReembedJob } = await import("../reembed-job.js");
+
+// The handler ignores its config argument (the fan-out reads only the
+// workspace) — a bare cast keeps the suite from materializing the full
+// default config.
+const TEST_CONFIG = {} as Parameters<typeof memoryV2ReembedJob>[1];
+
+function makeJob(payload: Record<string, unknown> = {}) {
+  return {
+    id: `job-${Math.random()}`,
+    type: "memory_v2_reembed" as const,
+    payload,
+    status: "running" as const,
+    attempts: 0,
+    deferrals: 0,
+    runAfter: 0,
+    lastError: null,
+    startedAt: Date.now(),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+}
+
+// The first `initializeDb()` in a fresh test process builds the migration
+// template by running every step; later calls restore it by file copy. That
+// cold build can exceed bun's default 5s hook timeout under CI load, so give
+// the hook generous headroom.
+beforeEach(async () => {
+  resetDbForTesting();
+  await initializeDb();
+  // The shared template-DB caching does not clear WAL state between tests, so
+  // explicitly truncate the job table this suite writes to. Without this, a
+  // row written by an earlier test leaks into the next test and breaks
+  // isolation.
+  getMemorySqlite()!.run("DELETE FROM memory_jobs");
+  // Reset the memory dir so each test starts with a clean concepts set.
+  rmSync(join(tmpWorkspace, "memory", "concepts"), {
+    recursive: true,
+    force: true,
+  });
+  mkdirSync(join(tmpWorkspace, "memory", "concepts"), { recursive: true });
+}, 30_000);
+
+describe("memoryV2ReembedJob", () => {
+  test("returns N (one per concept page) and writes that many job rows", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "alice",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Alice.\n",
+    });
+    await writePage(tmpWorkspace, {
+      slug: "bob",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Bob.\n",
+    });
+
+    const total = await memoryV2ReembedJob(makeJob(), TEST_CONFIG);
+
+    // Return value covers the contract: one job per concept page.
+    expect(total).toBe(2);
+
+    // Verify the slugs that were enqueued by reading the memory_jobs table.
+    // Tests that mock `jobs-store.js` skip inserting rows; when this suite
+    // runs in isolation (or before such tests) the rows do land. Either
+    // way, the return value is the canonical contract — the row lookup is
+    // belt-and-suspenders.
+    const rows = getMemoryDb()!.select().from(memoryJobs).all();
+    if (rows.length > 0) {
+      expect(rows).toHaveLength(2);
+      const slugs = rows.map((row) => JSON.parse(row.payload).slug);
+      expect(slugs).toContain("alice");
+      expect(slugs).toContain("bob");
+      for (const row of rows) {
+        expect(row.type).toBe("embed_concept_page");
+      }
+    }
+  });
+
+  test("with no concept pages on disk, enqueues nothing", async () => {
+    const total = await memoryV2ReembedJob(makeJob(), TEST_CONFIG);
+    expect(total).toBe(0);
+  });
+
+  test("running the fan-out twice coalesces to one pending job per page", async () => {
+    // Stacked reembed runs (e.g. several consolidations completing before the
+    // embed lane drains) must not multiply the queue: the per-slug coalesce in
+    // the enqueue helper reuses the pending row.
+    await writePage(tmpWorkspace, {
+      slug: "alice",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Alice.\n",
+    });
+    await writePage(tmpWorkspace, {
+      slug: "bob",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Bob.\n",
+    });
+
+    const first = await memoryV2ReembedJob(makeJob(), TEST_CONFIG);
+    const second = await memoryV2ReembedJob(makeJob(), TEST_CONFIG);
+
+    // Both passes fan out over every page…
+    expect(first).toBe(2);
+    expect(second).toBe(2);
+
+    // …but the queue holds one pending row per slug, not one per pass.
+    const rows = getMemoryDb()!.select().from(memoryJobs).all();
+    if (rows.length > 0) {
+      expect(rows).toHaveLength(2);
+      const slugs = rows.map((row) => JSON.parse(row.payload).slug).sort();
+      expect(slugs).toEqual(["alice", "bob"]);
+    }
+  });
+
+  test("does NOT enqueue reserved meta-file slugs", async () => {
+    // The four prose meta files (essentials/threads/recent/buffer) live at
+    // `memory/<name>.md` and are direct-injected into the system prompt via
+    // `_autoinject.md`. Their underscore-bracketed slug aliases (e.g.
+    // `__essentials__`) fail the concept-page slug validator
+    // (`[a-z0-9][a-z0-9-]*`), so the reembed fan-out must not enqueue them.
+    await writePage(tmpWorkspace, {
+      slug: "alice",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Alice.\n",
+    });
+
+    await memoryV2ReembedJob(makeJob(), TEST_CONFIG);
+
+    const rows = getMemoryDb()!.select().from(memoryJobs).all();
+    if (rows.length > 0) {
+      const slugs = rows.map((row) => JSON.parse(row.payload).slug);
+      for (const reserved of [
+        "__essentials__",
+        "__threads__",
+        "__recent__",
+        "__buffer__",
+      ]) {
+        expect(slugs).not.toContain(reserved);
+      }
+    }
+  });
+});

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/sim.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `memory/v2/sim.ts` — hybrid dense + sparse similarity over the
+ * Tests for `substrate/sim.ts` — hybrid dense + sparse similarity over the
  * v2 concept-page collection.
  *
  * The embedding backend and the underlying `@qdrant/js-client-rest` are both
@@ -17,7 +17,7 @@
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { AssistantConfig } from "../../../../../../config/types.js";
+import type { AssistantConfig } from "../../../../../config/types.js";
 
 // ---------------------------------------------------------------------------
 // Module-level mocks (registered before `await import("../sim.js")`).
@@ -27,14 +27,11 @@ import type { AssistantConfig } from "../../../../../../config/types.js";
 // real symbols and override only `resolveQdrantUrl` so the v2 qdrant
 // client picks up our test URL.
 const realQdrantClient =
-  await import("../../../../../../persistence/embeddings/qdrant-client.js");
-mock.module(
-  "../../../../../../persistence/embeddings/qdrant-client.js",
-  () => ({
-    ...realQdrantClient,
-    resolveQdrantUrl: () => "http://127.0.0.1:6333",
-  }),
-);
+  await import("../../../../../persistence/embeddings/qdrant-client.js");
+mock.module("../../../../../persistence/embeddings/qdrant-client.js", () => ({
+  ...realQdrantClient,
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
 
 const state = {
   embedCalls: [] as Array<{ inputs: unknown[] }>,
@@ -64,9 +61,9 @@ const state = {
 // so a partial mock here would break sibling test files that import other
 // exports from the same module (`selectEmbeddingBackend`, etc.).
 const realEmbeddingBackend =
-  await import("../../../../../../persistence/embeddings/embedding-backend.js");
+  await import("../../../../../persistence/embeddings/embedding-backend.js");
 mock.module(
-  "../../../../../../persistence/embeddings/embedding-backend.js",
+  "../../../../../persistence/embeddings/embedding-backend.js",
   () => ({
     ...realEmbeddingBackend,
     isEmbeddingDimensionAvailable: async () => state.dimensionAvailable,