@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/startup.ts

@@ -12,6 +12,15 @@
  * before this is kicked off — so the memory handlers are guaranteed to be in the
  * dispatch table before the jobs worker started near the end of this function
  * claims its first job.
+ *
+ * This is a multi-tier composition point, so the body carries `// ---- ... ----`
+ * section labels naming which tier owns each group of steps. The v1 labels also
+ * carry the `delete with v1` banner the deletion runbook greps for (see
+ * `../AGENTS.md`), so none of the three v1 blocks here can be missed at
+ * deletion time. The labels do not form a single contiguous run per tier: the
+ * v1 Qdrant collection ensure has to precede the shared embedding-identity
+ * reconcile, and the v1 graph bootstrap belongs to the post-worker seeding
+ * tail. Steps only move when the move is provably unobservable.
  */
 
 import { join } from "node:path";
@@ -38,15 +47,20 @@ import { resolveQdrantUrl } from "./embeddings.js";
 import { startMemoryJobsWorker } from "./jobs-worker.js";
 import { getLogger } from "./logging.js";
 import { getWorkspaceDir } from "./paths.js";
-import { sweepConceptPageFrontmatter } from "./v3/substrate/frontmatter-sweep.js";
+// ---- substrate (v2+v3) ---- the only tier-owned static import group here;
+// the v1 steps reach their modules through dynamic `./v1/*` imports so the
+// legacy engine loads only on the tier that runs it.
 import {
-  maybeRebuildMemoryV2Concepts,
+  maybeRebuildConceptCollection,
   rebuildBm25CorpusStatsAndReseedSkills,
-} from "./v3/substrate/memory-v2-startup.js";
+} from "./substrate/boot-maintenance.js";
+import { sweepConceptPageFrontmatter } from "./substrate/frontmatter-sweep.js";
 
 const log = getLogger("memory-startup");
 
 export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
+  // ---- shared infra ----
+  // Boot the Qdrant process every tier's vector work sits on.
   const qdrantUrl = resolveQdrantUrl();
   log.info({ qdrantUrl }, "Daemon startup: initializing Qdrant");
   const manager = createQdrantManager({ url: qdrantUrl });
@@ -80,6 +94,13 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
   }
 
   if (qdrantStarted) {
+    // ---- v1 (legacy engine) — delete with v1 ----
+    // Stays ahead of the shared embedding-identity reconcile below: that
+    // reconcile persists a new `memory.qdrant.vectorSize` on a commit-fresh or
+    // migrate action, and the v1 client must have been constructed at the
+    // dimension it owns before that happens (see `daemon/embedding-reconcile.ts`,
+    // which skips itself entirely on a v2-disabled install for the same reason).
+    //
     // Skip the v1 Qdrant collection lifecycle when concept-page memory is
     // active — the v1 collection has no writers or readers (graph search is
     // bypassed) in that state, so ensuring/migrating it just maintains a
@@ -128,6 +149,7 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
       }
     }
 
+    // ---- shared infra ----
     // Initialize the messages lexical index — a dedicated sparse-only Qdrant
     // collection that is the lexical (BM25-style) replacement for SQLite FTS5
     // over message content. Independent of the v1 dense collection lifecycle
@@ -161,31 +183,24 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
       );
     }
 
-    // Detect schema drift on the v2 concept-page collection (e.g.
-    // pre-#29823 collections lacking summary_dense / summary_sparse) and
-    // recreate + enqueue a reembed when needed. Awaited inline so the
-    // reembed enqueue happens before the memory worker drains its first
-    // batch; the call's own try/catch keeps any v2-side failure from
-    // blocking the v1 PKB reconcile or BM25 build below.
-    try {
-      await maybeRebuildMemoryV2Concepts(config);
-    } catch (err) {
-      log.warn(
-        { err },
-        "Memory v2 collection schema check threw — continuing startup",
-      );
-    }
-
+    // ---- v1 (legacy engine) — delete with v1 ----
     // Reconcile the PKB Qdrant index against the on-disk tree. Gated off
     // while concept-page memory is active because PKB is the v1 storage
     // layer; in that state the v1 collection is not initialized, so calling
     // `getQdrantClient()` here would throw. Fire-and-forget so enqueued
     // re-index jobs drain in the background and first-turn latency stays
     // unaffected.
+    //
+    // Sits ahead of the substrate block purely so each tier's steps are
+    // contiguous: the two are mutually exclusive on `usesConceptPageMemory`
+    // — every substrate step below re-checks the same predicate and returns
+    // immediately when v1 is the live tier — so their relative order is
+    // unobservable.
     if (!usesConceptPageMemory(config.memory)) {
       void (async () => {
         try {
-          const { reconcilePkbIndex } = await import("./pkb/pkb-reconcile.js");
+          const { reconcilePkbIndex } =
+            await import("./v1/pkb/pkb-reconcile.js");
           const pkbRoot = join(getWorkspaceDir(), "pkb");
           await reconcilePkbIndex(pkbRoot);
         } catch (err) {
@@ -197,6 +212,22 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
       })();
     }
 
+    // ---- substrate (v2+v3) ----
+    // Detect schema drift on the v2 concept-page collection (e.g.
+    // pre-#29823 collections lacking summary_dense / summary_sparse) and
+    // recreate + enqueue a reembed when needed. Awaited inline so the
+    // reembed enqueue happens before the memory worker drains its first
+    // batch; the call's own try/catch keeps any v2-side failure from
+    // blocking the BM25 build or the frontmatter sweep below.
+    try {
+      await maybeRebuildConceptCollection(config);
+    } catch (err) {
+      log.warn(
+        { err },
+        "Memory v2 collection schema check threw — continuing startup",
+      );
+    }
+
     void rebuildBm25CorpusStatsAndReseedSkills(config);
 
     try {
@@ -209,6 +240,7 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
     }
   }
 
+  // ---- shared infra ----
   // `startMemoryJobsWorker` spawns the out-of-process memory worker as a child
   // of the daemon; it is the sole drainer of the memory job queue. Shutdown
   // stops it — see shutdown-handlers.ts and the memory plugin's `shutdown`
@@ -218,7 +250,11 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
   log.info("Daemon startup: starting memory worker");
   startMemoryJobsWorker();
 
-  // Seed capability graph nodes (new memory graph system)
+  // Seed capability graph nodes (new memory graph system). All-tier, not v1:
+  // `refreshSkillCapabilityMemories` seeds both the graph nodes the
+  // `list_memory` surface reads on every tier and the substrate's skill /
+  // CLI-command cards, and `capability-seed.ts` self-skips the v1-only
+  // `embed_graph_node` enqueues when v1 is not the live tier.
   try {
     const { seedCliGraphNodes } = await import("./graph/capability-seed.js");
     refreshSkillCapabilityMemories(config);
@@ -227,12 +263,13 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
     log.warn({ err }, "Graph capability seeding failed — continuing");
   }
 
+  // ---- v1 (legacy engine) — delete with v1 ----
   // Auto-bootstrap: if the graph has no non-procedural nodes but historical
   // segments exist, enqueue a one-time graph_bootstrap job to populate the
   // graph from conversation history and journal files.
   try {
     const { maybeEnqueueGraphBootstrap, cleanupStaleItemVectors } =
-      await import("./graph/bootstrap.js");
+      await import("./v1/graph/bootstrap.js");
     maybeEnqueueGraphBootstrap();
     // Fire-and-forget: clean up orphaned Qdrant vectors from dropped memory_items table
     void cleanupStaleItemVectors().catch((err) =>

package/src/plugins/defaults/memory/substrate/__tests__/boot-maintenance.test.ts

@@ -0,0 +1,335 @@
+/**
+ * Tests for the boot-maintenance helpers in `boot-maintenance.ts`:
+ *
+ * - `maybeReseedCapabilitiesAfterManagedCredential`: the secrets route calls
+ *   this when a managed-proxy credential lands, to close the first-boot race
+ *   where the daemon's startup capability seed (skills + CLI commands) runs
+ *   before the platform provisions the managed embedding credential — the
+ *   seed's embed throws and the synthetic capability pages never reach the
+ *   page index. The reseed must fire only when the substrate is active AND the
+ *   managed-proxy prerequisites are now satisfied, so self-hosted / BYOK
+ *   assistants (no managed proxy) are never made to run a doomed embed. When
+ *   v3 is live it then enqueues a `memory_v3_maintain` job so v3 picks up the
+ *   capability pages immediately instead of waiting out the 6h maintain
+ *   backstop.
+ *
+ * - `maybeRebuildConceptCollection`: reembed-enqueue dedup against an
+ *   in-flight `memory_v2_reembed` job.
+ *
+ * Dynamic-imported collaborators are mocked; `bun:test` isolates
+ * `mock.module` per test file. Every collaborator mock is installed at module
+ * scope, BEFORE the first import of the module under test, behind swappable
+ * delegate objects; tests retarget delegates instead of calling `mock.module`
+ * mid-file. This ordering is load-bearing: `mock.module` on a module that has
+ * already been evaluated is not reliably re-linked for a subsequent dynamic
+ * import across bun versions (CI's bun served the real, cached
+ * `qdrant.js` — pulled in via the real `embedding-reconcile.js` import graph —
+ * to the first rebuild test even after `mock.module` ran). Module-scope
+ * registration means the real collaborators never load at all.
+ */
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantConfig } from "../../../../../config/schema.js";
+
+const proxyState = { prereqs: true };
+const seedSkill = mock(async () => {});
+const seedCli = mock(async () => {});
+const enqueueJob = mock(
+  (_type: string, _payload: Record<string, unknown>) => 1,
+);
+
+/**
+ * Swappable delegates behind the module-scope mocks. A module namespace's
+ * export set is fixed at instantiation, so every export is declared up front
+ * and `withMocks` retargets the delegates instead of re-installing a mock.
+ */
+const jobsStoreDelegates: {
+  enqueueMemoryJob: (type: string, payload: Record<string, unknown>) => unknown;
+  hasActiveJobOfType: (type: string) => boolean;
+} = {
+  enqueueMemoryJob: enqueueJob,
+  hasActiveJobOfType: () => false,
+};
+
+const qdrantDelegates: {
+  ensureConceptPageCollection: () => Promise<{ migrated: boolean }>;
+  countConceptPagePoints: () => Promise<number>;
+  clearReembedSentinel: () => Promise<void>;
+} = {
+  ensureConceptPageCollection: async () => ({ migrated: false }),
+  countConceptPagePoints: async () => 0,
+  clearReembedSentinel: async () => {},
+};
+
+const pageStoreDelegates: {
+  hasConceptPages: (workspaceDir: string) => Promise<boolean>;
+} = {
+  hasConceptPages: async () => true,
+};
+
+mock.module("../../../../../providers/platform-proxy/context.js", () => ({
+  hasManagedProxyPrereqs: async () => proxyState.prereqs,
+}));
+
+// `config/memory-v3-gate.js` is deliberately NOT mocked. It is pure (its only
+// import is a type) and it is the predicate under test as much as
+// `boot-maintenance.ts` is: the tiers are selected by real config here, so a
+// semantics change in `usesConceptPageMemory` / `isMemoryV3Live` fails these
+// tests instead of passing against a hand-inlined copy.
+
+mock.module("../../../../../persistence/jobs-store.js", () => ({
+  enqueueMemoryJob: (type: string, payload: Record<string, unknown>) =>
+    jobsStoreDelegates.enqueueMemoryJob(type, payload),
+  hasActiveJobOfType: (type: string) =>
+    jobsStoreDelegates.hasActiveJobOfType(type),
+}));
+
+mock.module("../skill-store.js", () => ({
+  seedV2SkillEntries: seedSkill,
+}));
+
+mock.module("../cli-command-store.js", () => ({
+  seedV2CliCommandEntries: seedCli,
+}));
+
+mock.module("../qdrant.js", () => ({
+  ensureConceptPageCollection: () =>
+    qdrantDelegates.ensureConceptPageCollection(),
+  countConceptPagePoints: () => qdrantDelegates.countConceptPagePoints(),
+  clearReembedSentinel: () => qdrantDelegates.clearReembedSentinel(),
+  dropLegacySkillsCollection: async () => {},
+}));
+
+mock.module("../page-store.js", () => ({
+  hasConceptPages: (workspaceDir: string) =>
+    pageStoreDelegates.hasConceptPages(workspaceDir),
+}));
+
+// The real embedding-reconcile statically imports the real `../qdrant.js`
+// (among a large daemon graph); mocking it keeps that graph out of the module
+// cache entirely. No test here asserts on the reconcile itself — the reseed
+// path contains its failures by contract.
+mock.module("../../../../../daemon/embedding-reconcile.js", () => ({
+  reconcileEmbeddingIdentity: async () => {},
+}));
+
+const {
+  maybeRebuildConceptCollection,
+  maybeReseedCapabilitiesAfterManagedCredential,
+} = await import("../boot-maintenance.js");
+
+/**
+ * Substrate active (or not) via the v2 injection engine, with v3 NOT live:
+ * `usesConceptPageMemory` follows `enabled`, `isMemoryV3Live` is false.
+ */
+function configWithV2(enabled: boolean): AssistantConfig {
+  return { memory: { v2: { enabled } } } as unknown as AssistantConfig;
+}
+
+/**
+ * Substrate active with memory-v3 as the live injected source — the shape a
+ * v3-live assistant actually carries (`v2.enabled` stays set alongside
+ * `v3.live`).
+ */
+function configWithV3(): AssistantConfig {
+  return {
+    memory: { v2: { enabled: true }, v3: { live: true } },
+  } as unknown as AssistantConfig;
+}
+
+/** Poll until `m` has been called at least `n` times, or `timeoutMs` elapses. */
+async function waitForCalls(
+  m: { mock: { calls: unknown[] } },
+  n: number,
+  timeoutMs = 1000,
+): Promise<void> {
+  const start = Date.now();
+  while (m.mock.calls.length < n && Date.now() - start < timeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+afterEach(() => {
+  seedSkill.mockClear();
+  seedCli.mockClear();
+  enqueueJob.mockClear();
+  proxyState.prereqs = true;
+});
+
+describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
+  test("reseeds both skill and CLI entries when v2 is enabled and managed-proxy prereqs are satisfied", async () => {
+    proxyState.prereqs = true;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedSkill).toHaveBeenCalledTimes(1);
+    expect(seedCli).toHaveBeenCalledTimes(1);
+  });
+
+  test("enqueues a v3 maintain pass after reseeding when v3 is live", async () => {
+    proxyState.prereqs = true;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3());
+
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
+  });
+
+  test("reseeds but does not enqueue a v3 maintain pass when v3 is not live", async () => {
+    proxyState.prereqs = true;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedSkill).toHaveBeenCalledTimes(1);
+    expect(seedCli).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).not.toHaveBeenCalled();
+  });
+
+  test("no-op when v2 memory is disabled", async () => {
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(false));
+
+    expect(seedSkill).not.toHaveBeenCalled();
+    expect(seedCli).not.toHaveBeenCalled();
+    expect(enqueueJob).not.toHaveBeenCalled();
+  });
+
+  test("no-op for non-managed assistants (managed-proxy prereqs not satisfied)", async () => {
+    proxyState.prereqs = false;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedSkill).not.toHaveBeenCalled();
+    expect(seedCli).not.toHaveBeenCalled();
+    expect(enqueueJob).not.toHaveBeenCalled();
+  });
+
+  test("swallows a seed failure and still reseeds the other catalog", async () => {
+    proxyState.prereqs = true;
+    seedSkill.mockImplementationOnce(async () => {
+      throw new Error('Embedding backend "gemini" is not configured');
+    });
+
+    // Must not reject — the helper contains each seed's failure so a doomed
+    // embed never propagates back to the credential-store caller.
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedCli).toHaveBeenCalledTimes(1);
+  });
+
+  test("enqueues the v3 maintain pass even when one catalog reseed rejects", async () => {
+    proxyState.prereqs = true;
+    seedSkill.mockImplementationOnce(async () => {
+      throw new Error('Embedding backend "gemini" is not configured');
+    });
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3());
+
+    // The CLI catalog seeded, so v3 must still rebuild its lanes — a single
+    // catalog failure cannot suppress the maintain pass.
+    expect(seedCli).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
+  });
+
+  test("enqueues the v3 maintain pass without blocking when a catalog reseed exceeds the timeout", async () => {
+    proxyState.prereqs = true;
+    // Skill reseed never settles — mirrors the wedged getCatalog()/embed seen in
+    // the field. The CLI reseed completes normally.
+    seedSkill.mockImplementationOnce(() => new Promise<void>(() => {}));
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3(), {
+      reseedTimeoutMs: 20,
+    });
+
+    // An unbounded `Promise.all` barrier would hang here forever; the bounded
+    // barrier lets the CLI catalog's maintain pass enqueue regardless.
+    expect(seedCli).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
+  });
+
+  test("re-enqueues the v3 maintain pass when a straggler catalog finishes after the timeout", async () => {
+    proxyState.prereqs = true;
+    let resolveSkill!: () => void;
+    seedSkill.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveSkill = resolve;
+        }),
+    );
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3(), {
+      reseedTimeoutMs: 10,
+    });
+
+    // Post-barrier enqueue fires once even though the skill catalog is still
+    // embedding.
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+
+    // The straggler lands; maintain re-enqueues so its late capability rows are
+    // reconciled without waiting out the 6h backstop.
+    resolveSkill();
+    await waitForCalls(enqueueJob, 2);
+    expect(enqueueJob).toHaveBeenCalledTimes(2);
+  });
+});
+
+/**
+ * Retarget the module-scope delegates at fresh spies for one
+ * `maybeRebuildConceptCollection` test and return them.
+ *
+ * Drives the empty-after-create branch (collection not migrated, zero points,
+ * pages on disk) so the reembed enqueue decision is reached, and lets the test
+ * choose whether a `memory_v2_reembed` job is already in-flight.
+ * `hasConceptPages` ignores its workspace-dir argument, so the real
+ * `getWorkspaceDir()` (resolving to the preload's per-test temp workspace)
+ * needs no mock.
+ */
+function withMocks(opts: { reembedInFlight: boolean }) {
+  const spies = {
+    enqueueMemoryJob: mock(() => "job-id"),
+    hasActiveJobOfType: mock(
+      (type: string) => opts.reembedInFlight && type === "memory_v2_reembed",
+    ),
+    ensureConceptPageCollection: mock(async () => ({ migrated: false })),
+    countConceptPagePoints: mock(async () => 0),
+    clearReembedSentinel: mock(async () => {}),
+    hasConceptPages: mock(async () => true),
+  };
+
+  jobsStoreDelegates.enqueueMemoryJob = spies.enqueueMemoryJob;
+  jobsStoreDelegates.hasActiveJobOfType = spies.hasActiveJobOfType;
+  qdrantDelegates.ensureConceptPageCollection =
+    spies.ensureConceptPageCollection;
+  qdrantDelegates.countConceptPagePoints = spies.countConceptPagePoints;
+  qdrantDelegates.clearReembedSentinel = spies.clearReembedSentinel;
+  pageStoreDelegates.hasConceptPages = spies.hasConceptPages;
+
+  return spies;
+}
+
+describe("maybeRebuildConceptCollection reembed dedup", () => {
+  test("does NOT enqueue a second reembed when one is already in-flight", async () => {
+    const spies = withMocks({ reembedInFlight: true });
+
+    await maybeRebuildConceptCollection(configWithV2(true));
+
+    expect(spies.hasActiveJobOfType).toHaveBeenCalledWith("memory_v2_reembed");
+    expect(spies.enqueueMemoryJob).toHaveBeenCalledTimes(0);
+    // The sentinel is still retired even when the enqueue is skipped.
+    expect(spies.clearReembedSentinel).toHaveBeenCalledTimes(1);
+  });
+
+  test("enqueues the reembed when none is in-flight", async () => {
+    const spies = withMocks({ reembedInFlight: false });
+
+    await maybeRebuildConceptCollection(configWithV2(true));
+
+    expect(spies.enqueueMemoryJob).toHaveBeenCalledTimes(1);
+    expect(spies.enqueueMemoryJob).toHaveBeenCalledWith(
+      "memory_v2_reembed",
+      {},
+    );
+    expect(spies.clearReembedSentinel).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/cli-command-store.ts`.
+ * Tests for `substrate/cli-command-store.ts`.
  *
  * Coverage matrix:
  *   - `seedV2CliCommandEntries` renders one `cli-commands/<name>` point per
@@ -19,7 +19,7 @@
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { CliCommandHelp } from "../../../../../../cli/lib/cli-command-help.js";
+import type { CliCommandHelp } from "../../../../../cli/lib/cli-command-help.js";
 
 // ---------------------------------------------------------------------------
 // Programmable test state
@@ -94,15 +94,17 @@ function setCommands(...commands: CliCommandHelp[]): void {
 // `CLI_COMMAND_HELP` from `@vellumai/plugin-api`, which re-exports it from
 // `cli/index.help.js` — mocking that module drives the seed with pure data,
 // so no test wires the Commander action graph.
-mock.module("../../../../../../cli/index.help.js", () => ({
+mock.module("../../../../../cli/index.help.js", () => ({
   CLI_COMMAND_HELP: state.commands,
 }));
 
 mock.module(
-  "../../../../../../persistence/embeddings/embedding-backend.js",
+  "../../../../../persistence/embeddings/embedding-backend.js",
   () => ({
     embedWithBackend: async (_config: unknown, inputs: unknown[]) => {
-      if (state.embedThrows) throw state.embedThrows;
+      if (state.embedThrows) {
+        throw state.embedThrows;
+      }
       const vectors = state.embedReturn.length
         ? state.embedReturn
         : inputs.map(() => [0.1, 0.2, 0.3]);
@@ -117,7 +119,7 @@ mock.module("../sparse-bm25.js", () => ({
   getConceptPageCorpusStats: () => null,
 }));
 
-mock.module("../../../../../../memory/v2/anisotropy.js", () => ({
+mock.module("../../anisotropy.js", () => ({
   applyCorrectionIfCalibrated: async (v: number[]) => v,
 }));
 
@@ -127,7 +129,9 @@ mock.module("../page-index.js", () => ({
 
 mock.module("../qdrant.js", () => ({
   upsertConceptPageEmbedding: async (params: UpsertCall) => {
-    if (state.upsertThrows) throw state.upsertThrows;
+    if (state.upsertThrows) {
+      throw state.upsertThrows;
+    }
     state.callSequence.push("upsert");
     state.upsertCalls.push(params);
   },
@@ -144,7 +148,9 @@ mock.module("../qdrant.js", () => ({
     kind: string,
     allowedSuffixes: ReadonlySet<string>,
   ) => {
-    if (state.backfillThrows) throw state.backfillThrows;
+    if (state.backfillThrows) {
+      throw state.backfillThrows;
+    }
     state.callSequence.push("backfill");
     state.backfillCalls.push({ prefix, kind, allowedSuffixes });
     return 0;