@vellumai/assistant 0.10.12 → 0.11.0-staging.2

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

@@ -20,7 +20,7 @@ import {
   getMemoryV2ActivationLogByMessageIds,
   type MemoryV2ConceptRowRecord,
   recordMemoryV2ActivationLog,
-} from "../memory-v2-activation-log-store.js";
+} from "../v2/activation-log-store.js";
 import {
   sampleConcepts,
   sampleConfig,

package/src/plugins/defaults/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -5,7 +5,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 let listPagesImpl: (workspaceDir: string) => Promise<string[]> = async () => [];
 
-mock.module("../v3/substrate/page-store.js", () => ({
+mock.module("../substrate/page-store.js", () => ({
   listPages: (workspaceDir: string) => listPagesImpl(workspaceDir),
 }));
 
@@ -18,8 +18,8 @@ import * as schema from "../../../../persistence/schema/index.js";
 import {
   type MemoryV2ConceptRowRecord,
   recordMemoryV2ActivationLog,
-} from "../memory-v2-activation-log-store.js";
-import { getConceptFrequencySummary } from "../memory-v2-concept-frequency.js";
+} from "../v2/activation-log-store.js";
+import { getConceptFrequencySummary } from "../v2/concept-frequency.js";
 import { sampleConfig } from "./fixtures/memory-v2-activation-fixtures.js";
 
 // The store and aggregator resolve the dedicated memory connection through

package/src/plugins/defaults/memory/__tests__/tools-delete-memory-page.test.ts

@@ -15,8 +15,8 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import type { ToolContext } from "../../../../tools/types.js";
+import { pageExists, writePage } from "../substrate/page-store.js";
 import { deleteMemoryPageTool } from "../tools.js";
-import { pageExists, writePage } from "../v3/substrate/page-store.js";
 
 let workspace: string;
 let prevWorkspaceEnv: string | undefined;

package/src/plugins/defaults/memory/context-search/sources/memory-v2.ts

@@ -29,16 +29,17 @@ import { extname, join } from "node:path";
 import { embedWithRetry } from "../../../../../persistence/embeddings/embed.js";
 import { getLogger } from "../../logging.js";
 import { isPathInsideRoot } from "../../path-containment.js";
-import { spreadActivation } from "../../v2/activation.js";
-import { getEdgeIndex } from "../../v3/substrate/edge-index.js";
+import { getEdgeIndex } from "../../substrate/edge-index.js";
 import {
   getConceptsDir,
   readPage,
   slugFromConceptPath,
-} from "../../v3/substrate/page-store.js";
-import { hybridQueryConceptPages } from "../../v3/substrate/qdrant.js";
-import { fuseHalf } from "../../v3/substrate/sim.js";
-import { generateBm25QueryEmbedding } from "../../v3/substrate/sparse-bm25.js";
+} from "../../substrate/page-store.js";
+import { hybridQueryConceptPages } from "../../substrate/qdrant.js";
+import { fuseHalf } from "../../substrate/sim.js";
+import { generateBm25QueryEmbedding } from "../../substrate/sparse-bm25.js";
+import { spreadActivation } from "../../substrate/spread.js";
+import { resolveSubstrateTuning } from "../../substrate/tuning.js";
 import type {
   RecallEvidence,
   RecallSearchContext,
@@ -48,8 +49,8 @@ import type {
 const log = getLogger("context-search-memory-v2-source");
 
 /**
- * Sentinel passed to Qdrant when `config.memory.v2.ann_candidate_limit` is
- * `null` (unlimited). Qdrant's query API requires an explicit numeric
+ * Sentinel passed to Qdrant when the `ann_candidate_limit` substrate tunable
+ * is `null` (unlimited). Qdrant's query API requires an explicit numeric
  * `limit`, so unlimited is represented as a number large enough that any
  * realistic concept-page collection is returned in full.
  *
@@ -167,27 +168,31 @@ async function activationEvidence(
   limit: number,
 ): Promise<RecallEvidence[]> {
   const trimmedQuery = query.trim();
-  if (trimmedQuery.length === 0) return [];
+  if (trimmedQuery.length === 0) {
+    return [];
+  }
 
   const denseResult = await embedWithRetry(context.config, [trimmedQuery], {
     signal: context.signal,
   });
   const denseVector = denseResult.vectors[0];
-  if (!denseVector || denseVector.length === 0) return [];
+  if (!denseVector || denseVector.length === 0) {
+    return [];
+  }
   const sparseVector = generateBm25QueryEmbedding(trimmedQuery);
 
-  const annLimit =
-    context.config.memory.v2.ann_candidate_limit ??
-    UNLIMITED_ANN_CANDIDATE_LIMIT;
+  const tuning = resolveSubstrateTuning(context.config.memory);
+  const annLimit = tuning.ann_candidate_limit ?? UNLIMITED_ANN_CANDIDATE_LIMIT;
   const hits = await hybridQueryConceptPages(
     denseVector,
     sparseVector,
     annLimit,
   );
-  if (hits.length === 0) return [];
+  if (hits.length === 0) {
+    return [];
+  }
 
-  const { dense_weight: denseWeight, sparse_weight: sparseWeight } =
-    context.config.memory.v2;
+  const { dense_weight: denseWeight, sparse_weight: sparseWeight } = tuning;
 
   // Mirror sim.ts: normalize body and summary sparse channels against their
   // own per-batch maxima, fuse each half via clamp01(dense·w_d + sparse·w_s),
@@ -229,17 +234,18 @@ async function activationEvidence(
   }
 
   const edgeIndex = await getEdgeIndex(context.workingDir);
-  const { k, hops } = context.config.memory.v2;
   const { final: finalActivation } = spreadActivation(
     ownActivation,
     edgeIndex,
-    k,
-    hops,
+    tuning.spread_k,
+    tuning.spread_hops,
   );
 
   const ranked = [...finalActivation.entries()]
     .sort(([slugA, valA], [slugB, valB]) => {
-      if (valB !== valA) return valB - valA;
+      if (valB !== valA) {
+        return valB - valA;
+      }
       return slugA < slugB ? -1 : slugA > slugB ? 1 : 0;
     })
     .slice(0, limit);
@@ -248,7 +254,9 @@ async function activationEvidence(
     ranked.map(async ([slug, score]) => {
       try {
         const page = await readPage(context.workingDir, slug);
-        if (!page) return null;
+        if (!page) {
+          return null;
+        }
         return { slug, score, body: page.body.trim() };
       } catch (err) {
         log.warn({ err, slug }, "Failed to read concept page during recall");
@@ -259,7 +267,9 @@ async function activationEvidence(
 
   const evidence: RecallEvidence[] = [];
   for (const entry of pages) {
-    if (!entry || entry.body.length === 0) continue;
+    if (!entry || entry.body.length === 0) {
+      continue;
+    }
     const locator = `memory/concepts/${entry.slug}.md`;
     evidence.push({
       id: `memory:v2:${entry.slug}`,
@@ -309,10 +319,14 @@ async function lexicalEvidence(
   limit: number,
 ): Promise<RecallEvidence[]> {
   const queryTerms = tokenizeSalientRecallTerms(query);
-  if (queryTerms.size === 0 || limit <= 0) return [];
+  if (queryTerms.size === 0 || limit <= 0) {
+    return [];
+  }
 
   const conceptsRoot = await resolveContainedConceptsRoot(context.workingDir);
-  if (!conceptsRoot) return [];
+  if (!conceptsRoot) {
+    return [];
+  }
 
   const matches: MemoryV2LexicalMatch[] = [];
   const visitedDirectories = new Set<string>([conceptsRoot]);
@@ -377,7 +391,9 @@ async function walkConceptsDirectory(
       continue;
     }
 
-    if (!isPathInsideRoot(entryRealPath, conceptsRoot)) continue;
+    if (!isPathInsideRoot(entryRealPath, conceptsRoot)) {
+      continue;
+    }
 
     let entryStats;
     try {
@@ -387,7 +403,9 @@ async function walkConceptsDirectory(
     }
 
     if (entryStats.isDirectory()) {
-      if (visitedDirectories.has(entryRealPath)) continue;
+      if (visitedDirectories.has(entryRealPath)) {
+        continue;
+      }
       visitedDirectories.add(entryRealPath);
       await walkConceptsDirectory(
         entryRealPath,
@@ -413,7 +431,9 @@ async function walkConceptsDirectory(
       conceptsRoot,
       queryTerms,
     );
-    if (match) matches.push(match);
+    if (match) {
+      matches.push(match);
+    }
   }
 }
 
@@ -431,7 +451,9 @@ async function searchConceptFile(
 
   const lines = contents.split(/\r?\n/);
   const bestLine = findBestLine(lines, queryTerms);
-  if (!bestLine) return null;
+  if (!bestLine) {
+    return null;
+  }
 
   const slug = slugFromConceptPath(conceptsRoot, filePath);
   const slugTerms = termOverlap(tokenizeSalientRecallTerms(slug), queryTerms);
@@ -460,7 +482,9 @@ function findBestLine(
   lines.forEach((line, lineIndex) => {
     const lineTerms = tokenizeSalientRecallTerms(line);
     const matchedTerms = termOverlap(lineTerms, queryTerms);
-    if (matchedTerms.size === 0) return;
+    if (matchedTerms.size === 0) {
+      return;
+    }
 
     const score = matchedTerms.size * 10 + Math.min(lineTerms.size, 12) / 100;
     if (!best || score > best.score) {
@@ -486,7 +510,9 @@ function buildLexicalExcerpt(
     .join("\n")
     .trim();
 
-  if (excerpt.length <= MEMORY_V2_LEXICAL_EXCERPT_MAX_CHARS) return excerpt;
+  if (excerpt.length <= MEMORY_V2_LEXICAL_EXCERPT_MAX_CHARS) {
+    return excerpt;
+  }
 
   const focusedLine = `${lineIndex + 1}: ${lines[lineIndex]?.trimEnd() ?? ""}`;
   if (focusedLine.length <= MEMORY_V2_LEXICAL_EXCERPT_MAX_CHARS) {
@@ -520,9 +546,13 @@ function compareLexicalMatches(
   a: MemoryV2LexicalMatch,
   b: MemoryV2LexicalMatch,
 ): number {
-  if (b.score !== a.score) return b.score - a.score;
+  if (b.score !== a.score) {
+    return b.score - a.score;
+  }
   const slugCompare = a.slug.localeCompare(b.slug);
-  if (slugCompare !== 0) return slugCompare;
+  if (slugCompare !== 0) {
+    return slugCompare;
+  }
   return a.lineNumber - b.lineNumber;
 }
 
@@ -548,7 +578,9 @@ function mergeMemoryV2Evidence(
     ),
   ]) {
     const key = `${item.locator}\0${normalizeExcerpt(item.excerpt)}`;
-    if (seen.has(key)) continue;
+    if (seen.has(key)) {
+      continue;
+    }
     seen.add(key);
     merged.push(item);
   }
@@ -572,7 +604,9 @@ function termOverlap(
 ): Set<string> {
   const matchedTerms = new Set<string>();
   for (const term of queryTerms) {
-    if (haystackTerms.has(term)) matchedTerms.add(term);
+    if (haystackTerms.has(term)) {
+      matchedTerms.add(term);
+    }
   }
   return matchedTerms;
 }
@@ -582,7 +616,9 @@ function normalizeExcerpt(excerpt: string): string {
 }
 
 function truncateExcerpt(text: string, maxChars: number): string {
-  if (text.length <= maxChars) return text;
+  if (text.length <= maxChars) {
+    return text;
+  }
   return `${text.slice(0, maxChars - 3).trimEnd()}...`;
 }
 

package/src/plugins/defaults/memory/context-search/sources/memory.ts

@@ -1,10 +1,10 @@
 import { usesConceptPageMemory } from "../../../../../config/memory-v3-gate.js";
 import { embedWithRetry } from "../../../../../persistence/embeddings/embed.js";
 import { generateSparseEmbedding } from "../../../../../persistence/embeddings/embedding-backend.js";
-import { searchGraphNodes } from "../../graph/graph-search.js";
 import { getNodesByIds } from "../../graph/store.js";
 import type { MemoryNode, MemoryType } from "../../graph/types.js";
 import { getLogger } from "../../logging.js";
+import { searchGraphNodes } from "../../v1/graph/graph-search.js";
 import type {
   RecallEvidence,
   RecallSearchContext,
@@ -24,6 +24,10 @@ export async function searchMemorySource(
     return { evidence: [] };
   }
 
+  // Tier dispatch: under the concept-page substrate (v2/v3) recall reads
+  // concept pages; on v1 it falls through to the legacy graph-node search
+  // below. V1 — delete with v1: everything after this early return is the v1
+  // arm, so the source collapses to the `usesConceptPageMemory` delegation.
   if (usesConceptPageMemory(context.config.memory)) {
     return searchMemoryV2Source(query, context, normalizedLimit);
   }

package/src/plugins/defaults/memory/fork-conversation-memory.ts

@@ -1,6 +1,10 @@
 import type { DrizzleDb } from "../../../persistence/db-connection.js";
 import { forkGraphMemoryState } from "./graph/graph-memory-state-store.js";
 import { forkRetrospectiveState } from "./memory-retrospective-state.js";
+import {
+  extractInjectedConceptSlugs,
+  readInjectedBlock,
+} from "./substrate/injected-block-slugs.js";
 import {
   forkActivationState,
   seedForkActivationState,
@@ -10,10 +14,6 @@ import {
   MEMORY_V3_INJECTED_BLOCK_METADATA_KEY,
   seedEverInjectedFromSlugs,
 } from "./v3/ever-injected-store.js";
-import {
-  extractInjectedConceptSlugs,
-  readInjectedBlock,
-} from "./v3/substrate/injected-block-slugs.js";
 
 /** Inputs to {@link forkConversationMemory}. */
 export interface ForkConversationMemoryInput {

package/src/plugins/defaults/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -1,9 +1,10 @@
 /**
  * Tests for the v2 routing wired into `ConversationGraphMemory.prepareMemory`.
  *
- * The wiring layer at `conversation-graph-memory.ts` reads
- * `config.memory.v2.enabled` to decide whether to swap v1's injection step
- * for the v2 activation pipeline.
+ * The wiring layer at `conversation-graph-memory.ts` dispatches on
+ * `isV2InjectionEngineActive` to decide whether to swap v1's injection step
+ * for the v2 activation pipeline — so the v2 engine runs only when memory is
+ * on, `memory.v2.enabled` is set, and v3 is not the live injected source.
  *
  * This file uses the *real* `injectMemoryV2Block` and stubs only the
  * lower-level deps (Qdrant client, embedding backend) the way
@@ -59,7 +60,7 @@ const retrieveForTurnMock = mock(async () => ({
   queryVector: undefined,
   sparseVector: undefined,
 }));
-mock.module("../retriever.js", () => ({
+mock.module("../../v1/graph/retriever.js", () => ({
   loadContextMemory: loadContextMemoryMock,
   retrieveForTurn: retrieveForTurnMock,
 }));
@@ -191,7 +192,7 @@ const { getActiveSlugs: getV3ActiveSlugs, recordInjected: recordV3Injected } =
   await import("../../v3/ever-injected-store.js");
 const schema = await import("../../../../../persistence/schema/index.js");
 const { _resetMemoryV2QdrantForTests } =
-  await import("../../v3/substrate/qdrant.js");
+  await import("../../substrate/qdrant.js");
 const { hydrate: hydrateActivationState, save: saveActivationState } =
   await import("../../v2/activation-store.js");
 const { setStoredDb, clearStoredDb } =
@@ -211,7 +212,9 @@ const realDbModule =
 mock.module("../../../../../persistence/db-connection.js", () => ({
   ...realDbModule,
   getDb: () => {
-    if (!testDbHandle) throw new Error("test db not initialized");
+    if (!testDbHandle) {
+      throw new Error("test db not initialized");
+    }
     return testDbHandle;
   },
   getMemorySqlite: () => memorySqliteHandle,
@@ -246,13 +249,18 @@ function createTestDb(): DrizzleDb {
   return db;
 }
 
-function makeConfig(v2Enabled: boolean, memoryEnabled = true): AssistantConfig {
+function makeConfig(
+  v2Enabled: boolean,
+  memoryEnabled = true,
+  v3Live = false,
+): AssistantConfig {
   // Pin `router.enabled: false` so these tests exercise the activation
   // pipeline. Router-mode coverage lives in `memory/v2/__tests__/injection.test.ts`.
   return applyNestedDefaults({
     memory: {
       enabled: memoryEnabled,
       v2: { enabled: v2Enabled, router: { enabled: false } },
+      v3: { live: v3Live },
     },
   }) as AssistantConfig;
 }
@@ -390,7 +398,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(lastMsg?.role).toBe("user");
     const firstBlock = lastMsg?.content[0];
     expect(firstBlock?.type).toBe("text");
-    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    if (firstBlock?.type !== "text") {
+      throw new Error("unexpected block type");
+    }
     expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
     expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
     // No nested wrapper.
@@ -425,7 +435,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     const lastMsg = reinjected.runMessages[reinjected.runMessages.length - 1];
     const firstBlock = lastMsg?.content[0];
     expect(firstBlock?.type).toBe("text");
-    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    if (firstBlock?.type !== "text") {
+      throw new Error("unexpected block type");
+    }
     expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
     expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
     expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
@@ -531,7 +543,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     expect(result.injectedBlockText).not.toContain("<memory>");
     const lastMsg = result.runMessages[result.runMessages.length - 1];
     const firstBlock = lastMsg?.content[0];
-    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    if (firstBlock?.type !== "text") {
+      throw new Error("unexpected block type");
+    }
     expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
 
     // v1 retrieval is fully bypassed when v2 is enabled.
@@ -557,6 +571,62 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
   });
 });
 
+describe("ConversationGraphMemory.prepareMemory — v3-live suppresses the v2 engine", () => {
+  // `memory.v2.enabled` defaults true and stays set on v3-live assistants, so
+  // the dispatch must NOT read it directly: with v3 live, the v2
+  // router/activation pipeline (and its activation-log/injection-event
+  // writes) must not run even though the flag is on. This covers every
+  // `prepareMemory` caller, including ones without their own v3 guard (the
+  // persona workflow-leaf runner).
+  test("per-turn: v3 live with v2.enabled=true → v2 not routed, v1 fallback taken", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true, true, true);
+    const messages = makeMessages("Tell me about Alice's editor preferences");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("per-turn");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    // Dispatch falls through to the v1 retriever (its stub returns zero
+    // nodes) instead of routing into the v2 engine.
+    expect(retrieveForTurnMock).toHaveBeenCalled();
+    // The v2 activation pipeline embeds its hybrid queries through the
+    // embedding backend; zero calls proves the pipeline never started.
+    expect(embedWithBackendMock).not.toHaveBeenCalled();
+    // And it persisted no activation state for the conversation.
+    expect(await hydrateActivationState("conv-test-1")).toBeNull();
+  });
+
+  test("context-load: v3 live with v2.enabled=true → v2 not routed, v1 fallback taken", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = new ConversationGraphMemory("conv-test-v3-cl");
+    const config = makeConfig(true, true, true);
+    const messages = makeMessages("first message of the conversation here");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("context-load");
+    expect(result.injectedBlockText).toBeNull();
+    expect(loadContextMemoryMock).toHaveBeenCalled();
+    expect(embedWithBackendMock).not.toHaveBeenCalled();
+    expect(await hydrateActivationState("conv-test-v3-cl")).toBeNull();
+  });
+});
+
 describe("ConversationGraphMemory.prepareMemory — memory.enabled gate", () => {
   test("memory.enabled=false short-circuits per-turn path: mode=none, no injection, v2/v1 not called", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);

package/src/plugins/defaults/memory/graph/__tests__/handle-remember-v2.test.ts

@@ -28,7 +28,7 @@ const enqueueCalls: Array<{
   absPath: string;
 }> = [];
 
-mock.module("../../jobs/embed-pkb-file.js", () => ({
+mock.module("../../v1/jobs/embed-pkb-file.js", () => ({
   enqueuePkbIndexJob: (input: { pkbRoot: string; absPath: string }) => {
     enqueueCalls.push(input);
     return "job-mock-id";

package/src/plugins/defaults/memory/graph/capability-seed.ts

@@ -10,6 +10,7 @@ import { and, eq, like, sql } from "drizzle-orm";
 
 import { isAssistantFeatureFlagEnabled } from "../../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../../config/loader.js";
+import { isMemoryV1Active } from "../../../../config/memory-v3-gate.js";
 import { resolveSkillStates } from "../../../../config/skill-state.js";
 import {
   loadSkillCatalog,
@@ -17,7 +18,7 @@ import {
 } from "../../../../config/skills.js";
 import {
   enqueueMemoryJob,
-  isMemoryEnabled,
+  upsertEmbedGraphNodeJob,
 } from "../../../../persistence/jobs-store.js";
 import { memoryGraphNodes } from "../../../../persistence/schema/index.js";
 import {
@@ -26,7 +27,7 @@ import {
 } from "../../../../skills/catalog-cache.js";
 import { getLogger } from "../logging.js";
 import { memoryDbOrNull } from "../memory-db.js";
-import type { SkillCapabilityInput } from "../v3/substrate/skill-content.js";
+import type { SkillCapabilityInput } from "../substrate/skill-content.js";
 import { createNode } from "./store.js";
 import {
   CAPABILITY_CLI_SOURCE_PREFIX as CLI_SOURCE_PREFIX,
@@ -259,10 +260,17 @@ function buildSkillContent(input: SkillCapabilityInput): string {
  *
  * We store the sourceKey in sourceConversations[0] as a stable identifier
  * (capability nodes aren't tied to a real conversation).
+ *
+ * The node write itself is all-tier — the `list_memory` surface reads
+ * capability nodes on every tier. The `embed_graph_node` enqueue is v1-only:
+ * those rows target the v1 Qdrant collection, and dispatch discards them
+ * while concept-page memory is active.
  */
 function upsertCapabilityNode(sourceKey: string, content: string): void {
   const db = memoryDbOrNull("upsertCapabilityNode");
-  if (!db) return;
+  if (!db) {
+    return;
+  }
 
   // Find existing node by sourceKey stored in source_conversations JSON
   const existing = db
@@ -304,8 +312,8 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
       })
       .where(eq(memoryGraphNodes.id, existing.id))
       .run();
-    if (isMemoryEnabled()) {
-      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    if (isMemoryV1Active(getConfig())) {
+      upsertEmbedGraphNodeJob({ nodeId: existing.id });
     }
     return;
   }
@@ -338,8 +346,8 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
     imageRefs: null,
   });
 
-  if (isMemoryEnabled()) {
-    enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+  if (isMemoryV1Active(getConfig())) {
+    upsertEmbedGraphNodeJob({ nodeId: node.id });
   }
   log.info({ sourceKey, nodeId: node.id }, "Created capability graph node");
 }
@@ -349,7 +357,9 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
  */
 function deleteCapabilityNode(sourceKey: string): void {
   const db = memoryDbOrNull("deleteCapabilityNode");
-  if (!db) return;
+  if (!db) {
+    return;
+  }
   const existing = db
     .select()
     .from(memoryGraphNodes)
@@ -380,7 +390,9 @@ function deleteCapabilityNode(sourceKey: string): void {
  */
 function cleanupOldFormatCapabilityNodes(): void {
   const db = memoryDbOrNull("cleanupOldFormatCapabilityNodes");
-  if (!db) return;
+  if (!db) {
+    return;
+  }
   const now = Date.now();
 
   // --- skill:* old-format nodes ---
@@ -447,7 +459,9 @@ function cleanupOldFormatCapabilityNodes(): void {
  */
 function pruneStaleCapabilities(prefix: string, activeKeys: Set<string>): void {
   const db = memoryDbOrNull("pruneStaleCapabilities");
-  if (!db) return;
+  if (!db) {
+    return;
+  }
   const allCapabilities = db
     .select()
     .from(memoryGraphNodes)