@vellumai/assistant 0.10.12 → 0.11.0-staging.2

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

@@ -1,16 +1,19 @@
 /**
- * `default-memory` plugin injectors — the personal-memory per-turn injections.
+ * `default-memory` plugin injectors — the personal-memory per-turn injections,
+ * and the plugin's single injector entry point: {@link memoryInjectors} is the
+ * complete set `defaultMemoryPlugin` contributes, so the host registers memory
+ * injectors without reaching into a tier directory for one.
  *
  * Contributes the PKB `<knowledge_base>` block, the PKB `<system_reminder>`
- * (with hybrid-search hints), and the memory-v2 static `<info>` block. Each
- * reads its inputs directly off the {@link TurnContext} (and the workspace
- * memory/PKB files), runs its own gating (injection mode, the personal-memory
- * trust gate, the v2 cutover guard, null-input short-circuits), and returns an
+ * (with hybrid-search hints), the memory-v2 static `<info>` block, and the two
+ * memory-v3 injectors defined in `v3/injector.ts`. Each reads its inputs
+ * directly off the {@link TurnContext} (and the workspace memory/PKB files),
+ * runs its own gating (injection mode, the personal-memory trust gate, the
+ * memory-tier gate, null-input short-circuits), and returns an
  * {@link InjectionBlock} with the placement that yields the canonical
  * positional semantics.
  *
- * `defaultMemoryPlugin` contributes these (alongside the memory-v3 injectors in
- * `v3/injector.ts`) to the global injector registry
+ * `defaultMemoryPlugin` contributes the array to the global injector registry
  * (`plugins/injector-registry.ts`), which unions every plugin's injectors and
  * sorts by `order` into the single sequence `applyRuntimeInjections` walks each
  * turn. The shared ordering contract lives in {@link DEFAULT_INJECTOR_ORDER}.
@@ -20,7 +23,7 @@ import { resolve } from "node:path";
 
 import type { Message } from "@vellumai/plugin-api";
 
-import { usesConceptPageMemory } from "../../../config/memory-v3-gate.js";
+import { isMemoryV1Active } from "../../../config/memory-v3-gate.js";
 import type { InjectionMatcher } from "../../../context/strip-injections.js";
 import { getInContextPkbPaths } from "../../../daemon/pkb-context-tracker.js";
 import { buildPkbReminder } from "../../../daemon/pkb-reminder-builder.js";
@@ -37,11 +40,16 @@ import { getMemoryConfig } from "./config.js";
 import { getLiveGraphMemory } from "./graph/conversation-graph-memory.js";
 import { getLogger } from "./logging.js";
 import { getSandboxWorkingDir } from "./paths.js";
-import { getPkbAutoInjectList } from "./pkb/autoinject.js";
-import { readPkbContext } from "./pkb/context.js";
-import { searchPkbFiles } from "./pkb/pkb-search.js";
-import { getPkbRoot } from "./pkb/types.js";
-import { readMemoryV2StaticContent } from "./v3/substrate/static-context.js";
+// SUBSTRATE (v2+v3) — feeds `memoryV2StaticInjector`.
+import { readMemoryV2StaticContent } from "./substrate/static-context.js";
+// V1 — delete with v1. Feeds the PKB injector pair.
+import { getPkbAutoInjectList } from "./v1/pkb/autoinject.js";
+import { readPkbContext } from "./v1/pkb/context.js";
+import { searchPkbFiles } from "./v1/pkb/pkb-search.js";
+import { getPkbRoot } from "./v1/pkb/types.js";
+// V3 — delete with v3. Re-exported through `memoryInjectors` below so the
+// host registers them without importing `v3/` itself.
+import { memoryV3Injector, memoryV3SpotlightInjector } from "./v3/injector.js";
 
 const pkbReminderLog = getLogger("pkb-reminder");
 
@@ -56,18 +64,18 @@ const PKB_HINT_THRESHOLD = 0.5;
 const PKB_HINT_ARCHIVE_THRESHOLD = 0.7;
 
 /**
- * Read-side cutover guard. Under concept-page memory both `pkb-context` and
- * `pkb-reminder` silence themselves entirely — the `<knowledge_base>` content
- * and the generic recall/remember nudge are both supplanted by the static
- * memory block. They are also silenced when memory is disabled outright:
- * these injectors have no other `memory.enabled` gate, and a workspace with
- * leftover `pkb/*` files must not keep surfacing long-term memory after the
- * user turns memory off. NOW.md is workspace state independent of PKB and
- * fires unchanged.
+ * Read-side tier gate. The PKB injectors (`pkb-context`, `pkb-reminder`) are
+ * the v1 injection surface, active only when v1 is the live memory tier
+ * ({@link isMemoryV1Active}). Under concept-page memory both silence
+ * themselves entirely — the `<knowledge_base>` content and the generic
+ * recall/remember nudge are both supplanted by the static memory block. They
+ * are also silenced when memory is disabled outright: these injectors have no
+ * other `memory.enabled` gate, and a workspace with leftover `pkb/*` files
+ * must not keep surfacing long-term memory after the user turns memory off.
+ * NOW.md is workspace state independent of PKB and fires unchanged.
  */
 function isPkbInjectionSilenced(): boolean {
-  const memory = getMemoryConfig();
-  return memory.enabled === false || usesConceptPageMemory(memory);
+  return !isMemoryV1Active({ memory: getMemoryConfig() });
 }
 
 /**
@@ -103,12 +111,19 @@ const pkbContextInjector: Injector = {
     runMessages?: Message[],
   ): Promise<InjectionBlock | null> {
     const mode = ctx.mode ?? "full";
-    if (mode !== "full") return null;
-    if (isPkbInjectionSilenced()) return null;
+    if (mode !== "full") {
+      return null;
+    }
+    if (isPkbInjectionSilenced()) {
+      return null;
+    }
     const content = readGatedPkbContext(ctx.trust);
-    if (!content) return null;
-    if (hasInjectedUserTextBlock(runMessages, KNOWLEDGE_BASE_BLOCK_PREFIXES))
+    if (!content) {
+      return null;
+    }
+    if (hasInjectedUserTextBlock(runMessages, KNOWLEDGE_BASE_BLOCK_PREFIXES)) {
       return null;
+    }
     return {
       id: "pkb-context",
       text: buildPkbContextBlock(content),
@@ -138,9 +153,15 @@ const pkbReminderInjector: Injector = {
     runMessages?: Message[],
   ): Promise<InjectionBlock | null> {
     const mode = ctx.mode ?? "full";
-    if (mode !== "full") return null;
-    if (!isPkbActive(ctx.trust)) return null;
-    if (isPkbInjectionSilenced()) return null;
+    if (mode !== "full") {
+      return null;
+    }
+    if (!isPkbActive(ctx.trust)) {
+      return null;
+    }
+    if (isPkbInjectionSilenced()) {
+      return null;
+    }
     const reminder = await buildPkbReminderWithHints(ctx, runMessages);
     return {
       id: "pkb-reminder",
@@ -277,7 +298,9 @@ async function buildPkbReminderWithHints(
       hints = results
         .filter((r) => {
           const abs = resolve(pkbRoot, r.path);
-          if (inContext.has(abs)) return false;
+          if (inContext.has(abs)) {
+            return false;
+          }
           const threshold = r.path.replace(/\\/g, "/").startsWith("archive/")
             ? PKB_HINT_ARCHIVE_THRESHOLD
             : PKB_HINT_THRESHOLD;
@@ -286,8 +309,12 @@ async function buildPkbReminderWithHints(
         .sort((a, b) => {
           const aHasHybrid = a.hybridScore !== undefined;
           const bHasHybrid = b.hybridScore !== undefined;
-          if (aHasHybrid && !bHasHybrid) return -1;
-          if (!aHasHybrid && bHasHybrid) return 1;
+          if (aHasHybrid && !bHasHybrid) {
+            return -1;
+          }
+          if (!aHasHybrid && bHasHybrid) {
+            return 1;
+          }
           if (aHasHybrid && bHasHybrid) {
             return b.hybridScore! - a.hybridScore!;
           }
@@ -344,16 +371,23 @@ const memoryV2StaticInjector: Injector = {
     runMessages?: Message[],
   ): Promise<InjectionBlock | null> {
     const mode = ctx.mode ?? "full";
-    if (mode !== "full") return null;
+    if (mode !== "full") {
+      return null;
+    }
     // The consolidation agent reads and rewrites memory/buffer.md through
     // file tools; injecting the buffer section here would duplicate the
     // entire backlog into its context (and go stale as it edits the file).
     const content = readGatedMemoryV2Static(ctx.trust, {
       excludeBuffer: ctx.callSite === "memoryV2Consolidation",
     });
-    if (!content) return null;
-    if (hasInjectedUserTextBlock(runMessages, MEMORY_V2_STATIC_BLOCK_MATCHERS))
+    if (!content) {
       return null;
+    }
+    if (
+      hasInjectedUserTextBlock(runMessages, MEMORY_V2_STATIC_BLOCK_MATCHERS)
+    ) {
+      return null;
+    }
     return {
       id: "memory-v2-static",
       text: buildMemoryV2StaticBlock(content),
@@ -377,14 +411,25 @@ function buildMemoryV2StaticBlock(content: string): string {
 }
 
 /**
- * The `default-memory` plugin's personal-memory injectors, in ascending
- * `order`. `defaultMemoryPlugin` contributes these alongside the memory-v3
- * injectors; the registry sorts the union by `order` (see
- * {@link DEFAULT_INJECTOR_ORDER}), so this array's literal order is only a
- * readability convenience.
+ * Every injector the `default-memory` plugin contributes, in ascending
+ * `order`. This is the plugin's whole injector surface — `defaultMemoryPlugin`
+ * passes the array straight through, and the registry sorts the cross-plugin
+ * union by `order` (see {@link DEFAULT_INJECTOR_ORDER}), so this array's
+ * literal order is only a readability convenience.
  */
 export const memoryInjectors: Injector[] = [
+  // V1 — delete with v1. The PKB pair is the legacy engine's entire injection
+  // surface; both self-silence through `isPkbInjectionSilenced` whenever v1 is
+  // not the live tier.
   pkbContextInjector,
   pkbReminderInjector,
+  // SUBSTRATE (v2+v3). Emits the static `<info>` block read off the concept
+  // pages, so it serves the v2 injection engine and v3 alike. Its block id
+  // `memory-v2-static` is FROZEN: `daemon/conversation-runtime-assembly.ts`
+  // switches on it to capture the block into persisted message metadata.
   memoryV2StaticInjector,
+  // V3 — delete with v3. The frozen net-new card block and its ephemeral
+  // spotlight companion; both self-gate on `memory.v3.live`.
+  memoryV3Injector,
+  memoryV3SpotlightInjector,
 ];

package/src/plugins/defaults/memory/job-handlers.ts

@@ -10,55 +10,97 @@
  * Each handler is wrapped in an arrow that reads the imported binding at
  * dispatch time rather than capturing it eagerly, so a per-test `mock.module` of
  * the underlying handler is honored.
+ *
+ * The table is grouped into labeled per-tier sections (V1 / SUBSTRATE / V2
+ * ENGINE / V3 / RETROSPECTIVE) so retiring a tier is deleting its section and
+ * its import group. Registration keys off `type` alone, so the literal order
+ * is a readability convenience.
  */
 
-import { usesConceptPageMemory } from "../../../config/memory-v3-gate.js";
+import { isMemoryV1Active } from "../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../config/types.js";
 import type { MemoryJob } from "../../../persistence/jobs-store.js";
 import type { JobHandlerEntry } from "../../types.js";
-import { pkbCompactionJob, pkbFilingJob } from "./filing-jobs.js";
-import { bootstrapFromHistory } from "./graph/bootstrap.js";
-import { runConsolidation } from "./graph/consolidation.js";
-import { runDecayTick } from "./graph/decay.js";
-import { graphExtractJob } from "./graph/extraction-job.js";
+// The all-tier graph store: `embedGraphNodeJob` serves the V1 section,
+// `embedGraphTriggerJob` the SUBSTRATE one.
 import {
   embedGraphNodeJob,
   embedGraphTriggerJob,
 } from "./graph/graph-search.js";
-import { runNarrativeRefinement } from "./graph/narrative.js";
-import { runPatternScan } from "./graph/pattern-scan.js";
-import { backfillJob } from "./job-handlers/backfill.js";
+// SUBSTRATE (v2+v3).
+import { embedConceptPageJob } from "./jobs/embed-concept-page.js";
+import { getLogger } from "./logging.js";
+// RETROSPECTIVE (all tiers).
+import { memoryRetrospectiveJob } from "./memory-retrospective-job.js";
+import { skillCardInsertJob } from "./memory-retrospective-skill-card.js";
+import { memoryRetrospectiveSweepJob } from "./memory-retrospective-sweep.js";
+// SUBSTRATE (v2+v3).
+import { memoryV2ConsolidateJob } from "./substrate/consolidation-job.js";
+import { memoryV2ReembedJob } from "./substrate/reembed-job.js";
+import { memoryV2SweepJob } from "./substrate/sweep-job.js";
+// V1 — delete with v1.
+import { pkbCompactionJob, pkbFilingJob } from "./v1/filing-jobs.js";
+import { bootstrapFromHistory } from "./v1/graph/bootstrap.js";
+import { runConsolidation } from "./v1/graph/consolidation.js";
+import { runDecayTick } from "./v1/graph/decay.js";
+import { graphExtractJob } from "./v1/graph/extraction-job.js";
+import { runNarrativeRefinement } from "./v1/graph/narrative.js";
+import { runPatternScan } from "./v1/graph/pattern-scan.js";
+import { backfillJob } from "./v1/job-handlers/backfill.js";
 import {
   embedAttachmentJob,
   embedMediaJob,
   embedSegmentJob,
   embedSummaryJob,
-} from "./job-handlers/embedding.js";
+} from "./v1/job-handlers/embedding.js";
 import {
   deleteQdrantVectorsJob,
   rebuildIndexJob,
   sweepOrphanedGraphNodePointsJob,
-} from "./job-handlers/index-maintenance.js";
-import { embedConceptPageJob } from "./jobs/embed-concept-page.js";
-import { embedPkbFileJob } from "./jobs/embed-pkb-file.js";
-import { getLogger } from "./logging.js";
-import { memoryRetrospectiveJob } from "./memory-retrospective-job.js";
-import { skillCardInsertJob } from "./memory-retrospective-skill-card.js";
-import { memoryRetrospectiveSweepJob } from "./memory-retrospective-sweep.js";
+} from "./v1/job-handlers/index-maintenance.js";
+import { embedPkbFileJob } from "./v1/jobs/embed-pkb-file.js";
+// V2 ENGINE — delete with v2.
 import {
   memoryV2ActivationRecomputeJob,
   memoryV2MigrateJob,
-  memoryV2ReembedJob,
 } from "./v2/backfill-jobs.js";
+// V3.
 import { maintainJob as memoryV3MaintainJob } from "./v3/maintain-job.js";
-import { memoryV2ConsolidateJob } from "./v3/substrate/consolidation-job.js";
-import { memoryV2SweepJob } from "./v3/substrate/sweep-job.js";
 
 const log = getLogger("memory-job-handlers");
 
 // ── Graph lifecycle job handlers ──────────────────────────────────
 
-function graphDecayJob(job: MemoryJob): void {
+/**
+ * Tier gate shared by the v1 graph handlers below (the lifecycle jobs and
+ * `graph_extract`). These jobs mutate — and some LLM-process into — the legacy
+ * v1 graph, which only the v1 tier reads, so a stale or hand-enqueued row
+ * claimed while v1 is not the active memory tier must complete as a logged
+ * no-op instead of doing that work. Returns true when the row should be
+ * skipped.
+ *
+ * The condition is `isMemoryV1Active` and nothing else — the same predicate
+ * `processJob` applies to `V1_QDRANT_JOB_TYPES` in `jobs-worker.ts`, so every
+ * v1 job type answers to one definition of "v1 is the live tier". That
+ * predicate's docstring carries the memory-off semantics the two share: memory
+ * being off is not v1, so v1 work is skipped there exactly as it is under the
+ * concept-page substrate.
+ */
+function isStaleV1GraphJob(job: MemoryJob, config: AssistantConfig): boolean {
+  if (isMemoryV1Active(config)) {
+    return false;
+  }
+  log.info(
+    { jobId: job.id, type: job.type },
+    "Skipping v1 graph job — the legacy graph is not the active memory tier",
+  );
+  return true;
+}
+
+function graphDecayJob(job: MemoryJob, config: AssistantConfig): void {
+  if (isStaleV1GraphJob(job, config)) {
+    return;
+  }
   const result = runDecayTick();
   log.info({ jobId: job.id, ...result }, "Graph decay tick complete");
 }
@@ -67,6 +109,9 @@ async function graphConsolidateJob(
   job: MemoryJob,
   config: AssistantConfig,
 ): Promise<void> {
+  if (isStaleV1GraphJob(job, config)) {
+    return;
+  }
   const result = await runConsolidation(config);
   log.info(
     {
@@ -83,6 +128,9 @@ async function graphPatternScanJob(
   job: MemoryJob,
   config: AssistantConfig,
 ): Promise<void> {
+  if (isStaleV1GraphJob(job, config)) {
+    return;
+  }
   const result = await runPatternScan(config);
   log.info(
     {
@@ -98,6 +146,9 @@ async function graphNarrativeRefineJob(
   job: MemoryJob,
   config: AssistantConfig,
 ): Promise<void> {
+  if (isStaleV1GraphJob(job, config)) {
+    return;
+  }
   const result = await runNarrativeRefinement(config);
   log.info(
     {
@@ -109,11 +160,27 @@ async function graphNarrativeRefineJob(
   );
 }
 
+async function graphBootstrapJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  if (isStaleV1GraphJob(job, config)) {
+    return;
+  }
+  await bootstrapFromHistory();
+}
+
 /**
  * The memory feature's per-job-type handlers, registered directly into the
  * worker dispatch table by the memory plugin's `init` hook.
  */
 export const memoryJobHandlers: readonly JobHandlerEntry[] = [
+  // V1 — delete with v1.
+  // Segment/summary/media embedding, the Qdrant index-maintenance jobs, the
+  // graph lifecycle, and PKB filing. Their stale-row guards live at dispatch
+  // (`V1_QDRANT_JOB_TYPES` in `jobs-worker.ts`), in `isStaleV1GraphJob` above,
+  // and at the `jobs-worker.ts` scheduling sites — all three on the one
+  // `isMemoryV1Active` condition.
   {
     type: "embed_segment",
     handler: (job) => embedSegmentJob(job),
@@ -145,22 +212,18 @@ export const memoryJobHandlers: readonly JobHandlerEntry[] = [
     type: "embed_pkb_file",
     handler: (job, config) => embedPkbFileJob(job, config),
   },
-  {
-    type: "graph_trigger_embed",
-    handler: (job, config) => embedGraphTriggerJob(job, config),
-  },
   {
     type: "graph_extract",
     handler: async (job, config) => {
       // Stale rows enqueued by any unguarded v1 path must not consume
-      // embedding/extraction budget while concept-page memory is active.
-      if (usesConceptPageMemory(config.memory)) {
+      // embedding/extraction budget while v1 is not the live tier.
+      if (isStaleV1GraphJob(job, config)) {
         return;
       }
       await graphExtractJob(job, config);
     },
   },
-  { type: "graph_decay", handler: (job) => graphDecayJob(job) },
+  { type: "graph_decay", handler: (job, config) => graphDecayJob(job, config) },
   {
     type: "graph_consolidate",
     handler: (job, config) => graphConsolidateJob(job, config),
@@ -173,7 +236,29 @@ export const memoryJobHandlers: readonly JobHandlerEntry[] = [
     type: "graph_narrative_refine",
     handler: (job, config) => graphNarrativeRefineJob(job, config),
   },
-  { type: "graph_bootstrap", handler: () => bootstrapFromHistory() },
+  {
+    type: "graph_bootstrap",
+    handler: (job, config) => graphBootstrapJob(job, config),
+  },
+  {
+    type: "pkb_filing",
+    handler: (job) => pkbFilingJob(job),
+  },
+  {
+    type: "pkb_compaction",
+    handler: () => pkbCompactionJob(),
+  },
+
+  // SUBSTRATE (v2+v3).
+  // Concept-page embedding, the buffer sweep and consolidator, and the
+  // corpus reembed — shared by the v2 injection engine and v3, so they
+  // outlive v1 and v2 alike. `graph_trigger_embed` deliberately lives here
+  // rather than with the v1 graph jobs: it embeds trigger text the substrate
+  // reads (locked by `__tests__/jobs-worker-v2-graph-trigger-embed.test.ts`).
+  {
+    type: "graph_trigger_embed",
+    handler: (job, config) => embedGraphTriggerJob(job, config),
+  },
   {
     type: "embed_concept_page",
     handler: (job, config) => embedConceptPageJob(job, config),
@@ -187,29 +272,35 @@ export const memoryJobHandlers: readonly JobHandlerEntry[] = [
     handler: (job, config) => memoryV2ConsolidateJob(job, config),
   },
   {
-    type: "pkb_filing",
-    handler: (job) => pkbFilingJob(job),
-  },
-  {
-    type: "pkb_compaction",
-    handler: () => pkbCompactionJob(),
+    type: "memory_v2_reembed",
+    handler: (job, config) => memoryV2ReembedJob(job, config),
   },
+
+  // V2 ENGINE — delete with v2.
+  // Operator-triggered backfills owned by the activation/router engine: the
+  // one-shot v1→v2 synthesis and the persisted-activation recompute. The job
+  // types share the `memory_v2_` prefix with the substrate entries above, but
+  // the work is engine-local.
   {
     type: "memory_v2_migrate",
     handler: (job, config) => memoryV2MigrateJob(job, config),
   },
-  {
-    type: "memory_v2_reembed",
-    handler: (job, config) => memoryV2ReembedJob(job, config),
-  },
   {
     type: "memory_v2_activation_recompute",
     handler: (job, config) => memoryV2ActivationRecomputeJob(job, config),
   },
+
+  // V3.
+  // Topic-tree self-maintenance; the handler no-ops when v3 is not live.
   {
     type: "memory_v3_maintain",
     handler: (job, config) => memoryV3MaintainJob(job, config),
   },
+
+  // RETROSPECTIVE (all tiers).
+  // The retrospective pass and its cross-conversation sweep are tier-agnostic
+  // and survive every tier deletion. `skill_card_insert` is emitted only on
+  // v3 but is owned by the retrospective, so it groups here.
   {
     type: "memory_retrospective",
     handler: (job, config) => memoryRetrospectiveJob(job, config),

package/src/plugins/defaults/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -91,7 +91,7 @@ const upsertCalls: Array<{
 
 const deleteCalls: string[] = [];
 
-mock.module("../../v3/substrate/qdrant.js", () => ({
+mock.module("../../substrate/qdrant.js", () => ({
   upsertConceptPageEmbedding: async (params: {
     slug: string;
     dense: number[];
@@ -151,7 +151,7 @@ type MemoryJobMod = typeof import("../../../../../persistence/jobs-store.js");
 type MemoryJob = ReturnType<MemoryJobMod["claimMemoryJobs"]>[number];
 const { embedConceptPageJob, enqueueEmbedConceptPageJob } =
   await import("../embed-concept-page.js");
-const { writePage } = await import("../../v3/substrate/page-store.js");
+const { writePage } = await import("../../substrate/page-store.js");
 const { _resetQdrantBreaker, isQdrantBreakerOpen, withQdrantBreaker } =
   await import("../../../../../persistence/embeddings/qdrant-circuit-breaker.js");
 

package/src/plugins/defaults/memory/jobs/embed-concept-page.ts

@@ -43,15 +43,16 @@ import { embedWithBackend } from "../embeddings.js";
 import { BackendUnavailableError } from "../host-utils.js";
 import { getLogger } from "../logging.js";
 import { getWorkspaceDir } from "../paths.js";
-import { readPage } from "../v3/substrate/page-store.js";
+import { readPage } from "../substrate/page-store.js";
 import {
   deleteConceptPageEmbedding,
   upsertConceptPageEmbedding,
-} from "../v3/substrate/qdrant.js";
+} from "../substrate/qdrant.js";
 import {
   generateBm25DocEmbedding,
   getConceptPageCorpusStats,
-} from "../v3/substrate/sparse-bm25.js";
+} from "../substrate/sparse-bm25.js";
+import { resolveSubstrateTuning } from "../substrate/tuning.js";
 
 const log = getLogger("memory-v2-embed-concept-page");
 
@@ -81,7 +82,9 @@ export async function embedConceptPageJob(
   config: AssistantConfig,
 ): Promise<void> {
   const slug = asString(job.payload.slug);
-  if (!slug) return;
+  if (!slug) {
+    return;
+  }
 
   const workspaceDir = getWorkspaceDir();
   const page = await readPage(workspaceDir, slug);
@@ -214,7 +217,9 @@ export async function embedConceptPageJob(
     writeModel = embedded.model;
     for (let i = 0; i < appliedSlots.length; i++) {
       const vector = embedded.vectors[i];
-      if (!vector) continue;
+      if (!vector) {
+        continue;
+      }
       if (appliedSlots[i] === "body") {
         bodyDense = vector;
         bodyFresh = true;
@@ -227,7 +232,9 @@ export async function embedConceptPageJob(
   // Body embedding is the ground truth — without it the page can't surface.
   // (Cache hit paths populate `bodyDense` above; a fresh embed that returned
   // no vectors short-circuits here too.)
-  if (!bodyDense) return;
+  if (!bodyDense) {
+    return;
+  }
 
   // Sparse is cheap (in-process tokenization) and changes any time the body
   // changes, so we always recompute it rather than caching alongside dense.
@@ -236,11 +243,12 @@ export async function embedConceptPageJob(
   // corpus for the first time), fall back to the legacy TF-only encoding —
   // the next reembed pass overwrites the page once stats are available.
   const corpusStats = getConceptPageCorpusStats();
+  const { bm25_k1, bm25_b } = resolveSubstrateTuning(config.memory);
   const encodeSparse = (input: string) =>
     corpusStats
       ? generateBm25DocEmbedding(input, corpusStats, {
-          k1: config.memory.v2.bm25_k1,
-          b: config.memory.v2.bm25_b,
+          k1: bm25_k1,
+          b: bm25_b,
         })
       : generateSparseEmbedding(input);
   const sparse = encodeSparse(text);
@@ -344,10 +352,14 @@ function readEmbeddingCache(
       ),
     )
     .get();
-  if (!row || row.dimensions !== expectedDim) return null;
+  if (!row || row.dimensions !== expectedDim) {
+    return null;
+  }
   // A row without a contentHash is a legacy/corrupt entry — treat as a miss
   // and force a re-embed rather than misalign the cache key.
-  if (row.contentHash === null) return null;
+  if (row.contentHash === null) {
+    return null;
+  }
   const dense = row.vectorBlob
     ? blobToVector(row.vectorBlob as Buffer)
     : (JSON.parse(row.vectorJson!) as number[]);