@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -45,25 +45,28 @@ mock.module("../../../util/logger.js", () => ({
 
 // Stub the v1 retriever so we don't reach Qdrant. Both modes return zero
 // nodes — the v1 injection branch becomes a no-op, isolating the assertion
-// to "did the v2 routing fire?".
+// to "did the v2 routing fire?". Tracked via `mock()` so tests can also
+// assert that v1 retrieval is *not* called when v2 is enabled.
+const loadContextMemoryMock = mock(async () => ({
+  nodes: [],
+  serendipityNodes: [],
+  latencyMs: 1,
+  metrics: null,
+  queryVector: undefined,
+  sparseVector: undefined,
+  userQueryVector: undefined,
+  userQuerySparseVector: undefined,
+}));
+const retrieveForTurnMock = mock(async () => ({
+  nodes: [],
+  latencyMs: 1,
+  metrics: null,
+  queryVector: undefined,
+  sparseVector: undefined,
+}));
 mock.module("../retriever.js", () => ({
-  loadContextMemory: async () => ({
-    nodes: [],
-    serendipityNodes: [],
-    latencyMs: 1,
-    metrics: null,
-    queryVector: undefined,
-    sparseVector: undefined,
-    userQueryVector: undefined,
-    userQuerySparseVector: undefined,
-  }),
-  retrieveForTurn: async () => ({
-    nodes: [],
-    latencyMs: 1,
-    metrics: null,
-    queryVector: undefined,
-    sparseVector: undefined,
-  }),
+  loadContextMemory: loadContextMemoryMock,
+  retrieveForTurn: retrieveForTurnMock,
 }));
 
 // Programmable embedding + Qdrant state. Mirrors the pattern in
@@ -232,7 +235,7 @@ function makeMemory(): InstanceType<typeof ConversationGraphMemory> {
   // `initialized = true` skips the context-load branch and the
   // `fetchRecentSummaries` DB read it depends on, isolating the per-turn path
   // for these unit tests. Context-load is covered by its own block below.
-  const m = new ConversationGraphMemory("scope-1", "conv-test-1");
+  const m = new ConversationGraphMemory("conv-test-1");
   (m as unknown as { initialized: boolean }).initialized = true;
   return m;
 }
@@ -262,6 +265,8 @@ beforeEach(() => {
   testDbHandle = createTestDb();
   qdrantState.queryResponses.dense.length = 0;
   qdrantState.queryResponses.sparse.length = 0;
+  loadContextMemoryMock.mockClear();
+  retrieveForTurnMock.mockClear();
   _resetMemoryV2QdrantForTests();
 });
 
@@ -333,16 +338,57 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
 
     expect(result.mode).toBe("per-turn");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("<memory>");
+    expect(result.injectedBlockText).not.toContain("<memory>");
     expect(result.injectedBlockText).toContain("### alice-vscode");
 
-    // The leading content block on the user message is the v2 block.
+    // The leading content block on the user message is the v2 block,
+    // wrapped exactly once.
     const lastMsg = result.runMessages[result.runMessages.length - 1];
     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");
-    expect(firstBlock.text).toContain("<memory>");
+    expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
+    expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
+    // No nested wrapper.
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+
+    // v1 retrieval is fully bypassed when v2 is enabled.
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+  });
+
+  test("reinjectCachedMemory after v2 injection wraps exactly once (no double-wrap)", async () => {
+    // Regression for the double-wrap bug: v2 cached `lastInjectedBlock`
+    // already wrapped, then `reinjectCachedMemory` re-wrapped via
+    // `injectTextBlock`, producing `<memory>\n<memory>\n...\n</memory>\n</memory>`.
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const messages = makeMessages("Tell me about Alice's editor preferences");
+
+    const initial = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(initial.injectedBlockText).not.toBeNull();
+
+    // Simulate post-compaction: caller re-runs `applyRuntimeInjections`
+    // (which strips memory injections) and then asks for the cached
+    // memory to be re-prepended.
+    const reinjected = memory.reinjectCachedMemory(messages);
+    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");
+    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);
+    expect(firstBlock.text.match(/<\/memory>/g)?.length).toBe(1);
+    expect(firstBlock.text).toContain("### alice-vscode");
   });
 
   test("flag on + config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
@@ -371,7 +417,7 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     // Fresh memory → initialized=false → runContextLoad branch.
-    const memory = new ConversationGraphMemory("scope-1", "conv-test-cl");
+    const memory = new ConversationGraphMemory("conv-test-cl");
     const config = makeConfig(true);
     const messages = makeMessages("first message of the conversation here");
 
@@ -384,14 +430,24 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
 
     expect(result.mode).toBe("context-load");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("<memory>");
+    expect(result.injectedBlockText).toContain("### alice-vscode");
+    // injectedBlockText is the unwrapped inner content; the wrapper is
+    // applied at injection time on the run message.
+    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");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+
+    // v1 retrieval is fully bypassed when v2 is enabled.
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
   });
 
   test("flag off → v2 not run on first turn either", async () => {
     _setOverridesForTesting({ "memory-v2-enabled": false });
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
-    const memory = new ConversationGraphMemory("scope-1", "conv-test-cl-off");
+    const memory = new ConversationGraphMemory("conv-test-cl-off");
     const config = makeConfig(true);
     const messages = makeMessages("first message of the conversation here");
 

package/src/memory/graph/conversation-graph-memory.ts

@@ -62,14 +62,12 @@ export class ConversationGraphMemory {
   private initialized = false;
   private needsReload = false;
   private stateRestored = false;
-  private scopeId: string;
   private conversationId: string;
   private lastInjectedBlock: string | null = null;
   private lastInjectedNodeIds: string[] = [];
   private lastInjectedImages: Map<string, ResolvedImage> = new Map();
 
-  constructor(scopeId: string, conversationId: string) {
-    this.scopeId = scopeId;
+  constructor(conversationId: string) {
     this.conversationId = conversationId;
   }
 
@@ -147,7 +145,6 @@ export class ConversationGraphMemory {
       const db = getDb();
       const baseWhere = and(
         eq(memorySummaries.scope, "conversation"),
-        eq(memorySummaries.scopeId, this.scopeId),
         ne(memorySummaries.scopeKey, this.conversationId),
       );
 
@@ -385,29 +382,11 @@ export class ConversationGraphMemory {
     signal: AbortSignal,
     onEvent: (msg: ServerMessage) => void,
   ) {
-    const result = await loadContextMemory({
-      scopeId: this.scopeId,
-      recentSummaries,
-      userQuery,
-      config,
-      signal,
-    });
-
-    this.initialized = true;
-    this.needsReload = false;
-
-    // v2 routing: when the feature flag and workspace config are both on,
-    // replace v1's injection with the activation-pipeline output. v1
-    // retrieval still runs above so its tracker stays warm — keeps the
-    // off→on→off flag flip cheap and avoids invalidating cached metrics.
-    // assistantMessage is empty: context-load fires on turn 1 / post-
-    // compaction, so there is no immediately-prior assistant turn to
-    // weight the activation against.
-    //
     // Use the raw user text (no >10-char filter) so even short greetings
     // ("hi") get a fresh top-K activation dump on the first user message.
-    // The activation pipeline is robust to weak ANN signal — it still falls
-    // back to spreading + nowText to surface candidates.
+    // The activation pipeline is robust to weak ANN signal — it falls back
+    // to spreading + nowText to surface candidates.
+    const startedAt = Date.now();
     const rawUserText = readRawUserText(messages[messages.length - 1]);
     const v2 = await this.maybeRouteV2Injection(
       messages,
@@ -415,7 +394,11 @@ export class ConversationGraphMemory {
       "context-load",
       rawUserText ?? userQuery ?? "",
       "",
+      signal,
     );
+    this.initialized = true;
+    this.needsReload = false;
+
     if (v2.routed) {
       this.lastInjectedBlock = v2.injectedBlockText;
       this.lastInjectedNodeIds = [];
@@ -425,17 +408,22 @@ export class ConversationGraphMemory {
         injectedTokens: v2.injectedBlockText
           ? estimateTextTokens(v2.injectedBlockText)
           : 0,
-        latencyMs: result.latencyMs,
+        latencyMs: Date.now() - startedAt,
         mode: "context-load" as const,
         injectedBlockText: v2.injectedBlockText,
-        metrics: result.metrics,
-        queryVector: result.queryVector,
-        sparseVector: result.sparseVector,
-        userQueryVector: result.userQueryVector,
-        userQuerySparseVector: result.userQuerySparseVector,
+        metrics: null,
       };
     }
 
+    // v1 fallback — only reached when the v2 flag or workspace config is off.
+    const result = await loadContextMemory({
+      scopeId: "default",
+      recentSummaries,
+      userQuery,
+      config,
+      signal,
+    });
+
     if (result.nodes.length === 0) {
       this.lastInjectedBlock = null;
       this.lastInjectedNodeIds = [];
@@ -543,27 +531,16 @@ export class ConversationGraphMemory {
       if (userLastBlocks.length > 0 && assistantLast) break;
     }
 
-    const result = await retrieveForTurn({
-      assistantLastMessage: assistantLast,
-      userLastMessage: userLast,
-      userLastMessageBlocks: userLastBlocks,
-      scopeId: this.scopeId,
-      config,
-      tracker: this.tracker,
-      signal,
-    });
-
-    // v2 routing: same gating as `runContextLoad` — when the flag and config
-    // are both on, the v2 activation pipeline produces the injection block
-    // (or `null` for the cache-stable empty path). v1 retrieval above runs
-    // unconditionally so the tracker stays in sync with the v1 nodes —
-    // cheap insurance for an off→on→off flag flip mid-conversation.
+    // v2 path — skip v1 retrieval entirely when v2 is enabled. See the
+    // matching comment in `runContextLoad` for rationale.
+    const startedAt = Date.now();
     const v2 = await this.maybeRouteV2Injection(
       messages,
       config,
       "per-turn",
       userLast,
       assistantLast,
+      signal,
     );
     if (v2.routed) {
       this.lastInjectedBlock = v2.injectedBlockText;
@@ -574,15 +551,24 @@ export class ConversationGraphMemory {
         injectedTokens: v2.injectedBlockText
           ? estimateTextTokens(v2.injectedBlockText)
           : 0,
-        latencyMs: result.latencyMs,
+        latencyMs: Date.now() - startedAt,
         mode: "per-turn" as const,
         injectedBlockText: v2.injectedBlockText,
-        metrics: result.metrics,
-        queryVector: result.queryVector,
-        sparseVector: result.sparseVector,
+        metrics: null,
       };
     }
 
+    // v1 path (only reached when the v2 flag or workspace config is off).
+    const result = await retrieveForTurn({
+      assistantLastMessage: assistantLast,
+      userLastMessage: userLast,
+      userLastMessageBlocks: userLastBlocks,
+      scopeId: "default",
+      config,
+      tracker: this.tracker,
+      signal,
+    });
+
     if (result.nodes.length === 0) {
       this.lastInjectedBlock = null;
       this.lastInjectedNodeIds = [];
@@ -641,12 +627,12 @@ export class ConversationGraphMemory {
   }
 
   /**
-   * Route the v1 retrieval's injection step through the v2 activation
-   * pipeline when the `memory-v2-enabled` feature flag *and* the workspace
-   * config (`memory.v2.enabled`) are both on.
+   * Run the v2 activation pipeline when the `memory-v2-enabled` feature flag
+   * *and* the workspace config (`memory.v2.enabled`) are both on.
    *
    * The two outcomes the caller distinguishes via `routed`:
-   *   - `routed: false` — v2 disabled; caller runs the existing v1 injection.
+   *   - `routed: false` — v2 disabled; caller falls through to the legacy v1
+   *                        retrieval path.
    *   - `routed: true`  — v2 ran. `runMessages` is either the v2-prepended
    *                        message list (block was non-null) or the input
    *                        messages unchanged (cache-stable empty path).
@@ -658,6 +644,7 @@ export class ConversationGraphMemory {
     mode: InjectMemoryV2Mode,
     userMessage: string,
     assistantMessage: string,
+    signal: AbortSignal,
   ): Promise<{
     routed: boolean;
     runMessages: Message[];
@@ -683,6 +670,7 @@ export class ConversationGraphMemory {
       messageId: `${this.conversationId}:turn:${currentTurn}`,
       mode,
       config,
+      signal,
     });
 
     if (!result.block) {
@@ -691,7 +679,7 @@ export class ConversationGraphMemory {
 
     return {
       routed: true,
-      runMessages: prependMemoryV2Block(messages, result.block),
+      runMessages: injectTextBlock(messages, result.block),
       injectedBlockText: result.block,
     };
   }
@@ -881,26 +869,3 @@ function readRawUserText(message: Message | undefined): string | null {
   if (texts.length === 0) return null;
   return texts.join(" ");
 }
-
-/**
- * Prepend a pre-rendered `<memory>` block (produced by
- * `injectMemoryV2Block`) to the last user message. Unlike v1's
- * {@link injectMemoryBlock}, the input here is already wrapped — we
- * just need to attach it as a leading text block. We still strip any
- * pre-existing memory injections first so the layer is idempotent
- * across compaction-driven re-injection.
- */
-function prependMemoryV2Block(messages: Message[], block: string): Message[] {
-  if (block.trim().length === 0) return messages;
-  if (messages.length === 0) return messages;
-  const cleaned = stripExistingMemoryInjections(messages);
-  const userTail = cleaned[cleaned.length - 1];
-  if (!userTail || userTail.role !== "user") return messages;
-  return [
-    ...cleaned.slice(0, -1),
-    {
-      ...userTail,
-      content: [{ type: "text" as const, text: block }, ...userTail.content],
-    },
-  ];
-}

package/src/memory/graph/extraction.ts

@@ -1443,9 +1443,7 @@ async function findCandidateNodes(
       const embedding = await embedWithRetry(config, [searchText]);
       const queryVector = embedding.vectors[0];
       if (queryVector) {
-        const searchResults = await searchGraphNodes(queryVector, 100, [
-          scopeId,
-        ]);
+        const searchResults = await searchGraphNodes(queryVector, 100);
         for (const r of searchResults) allNodeIds.add(r.nodeId);
       }
     } catch (err) {

package/src/memory/graph/graph-search.test.ts

@@ -1,6 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
+
+// This test exercises the v1 graph search path. The `memory-v2-enabled` flag
+// (registry default `true`) makes graph-search short-circuit to keep traffic
+// off the legacy collection — disable it so the v1 path stays under test.
+_setOverridesForTesting({ "memory-v2-enabled": false });
 
 mock.module("../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
@@ -64,7 +70,7 @@ describe("searchGraphNodes — _meta filter parity", () => {
   });
 
   test("hybrid path excludes _meta sentinel points", async () => {
-    await searchGraphNodes([0.1], 5, ["default"], {
+    await searchGraphNodes([0.1], 5, {
       indices: [1],
       values: [1],
     });
@@ -80,7 +86,7 @@ describe("searchGraphNodes — _meta filter parity", () => {
   });
 
   test("dense-only path also excludes _meta sentinel points", async () => {
-    await searchGraphNodes([0.1], 5, ["default"]);
+    await searchGraphNodes([0.1], 5);
 
     expect(searchCalls).toHaveLength(1);
     const filter = searchCalls[0]?.filter as {
@@ -93,69 +99,6 @@ describe("searchGraphNodes — _meta filter parity", () => {
   });
 });
 
-describe("searchGraphNodes — excludeScopeIds", () => {
-  beforeEach(() => {
-    breakerOpen = false;
-    hybridSearchCalls.length = 0;
-    searchCalls.length = 0;
-  });
-
-  test("hybrid path adds memory_scope_id must_not when excludeScopeIds provided", async () => {
-    await searchGraphNodes(
-      [0.1],
-      5,
-      undefined,
-      { indices: [1], values: [1] },
-      undefined,
-      ["scope:abc", "scope:xyz"],
-    );
-
-    expect(hybridSearchCalls).toHaveLength(1);
-    const filter = hybridSearchCalls[0]?.filter as {
-      must_not: Array<Record<string, unknown>>;
-    };
-    const scopeExclude = filter.must_not.find(
-      (c) => c.key === "memory_scope_id",
-    ) as { match: { any: string[] } } | undefined;
-    expect(scopeExclude?.match.any).toEqual(["scope:abc", "scope:xyz"]);
-  });
-
-  test("dense-only path adds memory_scope_id must_not when excludeScopeIds provided", async () => {
-    await searchGraphNodes([0.1], 5, undefined, undefined, undefined, [
-      "scope:abc",
-    ]);
-
-    expect(searchCalls).toHaveLength(1);
-    const filter = searchCalls[0]?.filter as {
-      must_not: Array<Record<string, unknown>>;
-    };
-    const scopeExclude = filter.must_not.find(
-      (c) => c.key === "memory_scope_id",
-    ) as { match: { any: string[] } } | undefined;
-    expect(scopeExclude?.match.any).toEqual(["scope:abc"]);
-  });
-
-  test("hybrid path omits memory_scope_id must_not when excludeScopeIds is empty", async () => {
-    await searchGraphNodes(
-      [0.1],
-      5,
-      undefined,
-      { indices: [1], values: [1] },
-      undefined,
-      [],
-    );
-
-    expect(hybridSearchCalls).toHaveLength(1);
-    const filter = hybridSearchCalls[0]?.filter as {
-      must_not: Array<Record<string, unknown>>;
-    };
-    const scopeExclude = filter.must_not.find(
-      (c) => c.key === "memory_scope_id",
-    );
-    expect(scopeExclude).toBeUndefined();
-  });
-});
-
 describe("searchGraphNodes — prefetch floor", () => {
   beforeEach(() => {
     breakerOpen = false;
@@ -164,7 +107,7 @@ describe("searchGraphNodes — prefetch floor", () => {
   });
 
   test("hybrid prefetchLimit floors at 200 for small limits", async () => {
-    await searchGraphNodes([0.1], 10, ["default"], {
+    await searchGraphNodes([0.1], 10, {
       indices: [1],
       values: [1],
     });
@@ -174,7 +117,7 @@ describe("searchGraphNodes — prefetch floor", () => {
   });
 
   test("hybrid prefetchLimit scales with limit when limit*10 exceeds floor", async () => {
-    await searchGraphNodes([0.1], 50, ["default"], {
+    await searchGraphNodes([0.1], 50, {
       indices: [1],
       values: [1],
     });

package/src/memory/graph/graph-search.ts

@@ -2,8 +2,10 @@
 // Memory Graph — Qdrant vector search for graph nodes
 // ---------------------------------------------------------------------------
 
+import { getConfig } from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { embedAndUpsert } from "../job-utils.js";
@@ -36,18 +38,20 @@ export interface GraphSearchResult {
  * Semantic search across graph nodes in Qdrant. Returns scored node IDs
  * that the caller can hydrate from the graph store.
  *
- * Filters to `target_type: "graph_node"` and optionally by scope.
- * `excludeScopeIds` adds a `must_not` against `memory_scope_id` for callers
- * that need to omit specific scopes from a broader recall search.
+ * Filters to `target_type: "graph_node"`.
  */
 export async function searchGraphNodes(
   queryVector: number[],
   limit: number,
-  scopeIds?: string[],
   sparseVector?: QdrantSparseVector,
   dateRange?: { afterMs?: number; beforeMs?: number },
-  excludeScopeIds?: string[],
 ): Promise<GraphSearchResult[]> {
+  // v2 owns the read path when both gates are on. The v1 `memory` collection
+  // is in active retirement and a corrupted sparse segment can OOM-crash the
+  // shared Qdrant process — short-circuiting here keeps v1 background work
+  // and stale callers from taking v2 down with them.
+  if (isMemoryV2ReadActive(getConfig())) return [];
+
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
     return [];
@@ -58,21 +62,12 @@ export async function searchGraphNodes(
   const mustNot: Record<string, unknown>[] = [
     { key: "_meta", match: { value: true } },
   ];
-  if (excludeScopeIds && excludeScopeIds.length > 0) {
-    mustNot.push({
-      key: "memory_scope_id",
-      match: { any: excludeScopeIds },
-    });
-  }
 
   // Use hybrid search (dense + sparse with RRF fusion) when a non-empty
   // sparse vector is available; otherwise fall back to dense-only search.
   if (sparseVector && sparseVector.indices.length > 0) {
     const must: Record<string, unknown>[] = [
       { key: "target_type", match: { value: "graph_node" } },
-      ...(scopeIds && scopeIds.length > 0
-        ? [{ key: "memory_scope_id", match: { any: scopeIds } }]
-        : []),
     ];
     if (dateRange?.afterMs != null) {
       must.push({ key: "created_at", range: { gte: dateRange.afterMs } });
@@ -112,12 +107,6 @@ export async function searchGraphNodes(
     },
   ];
 
-  if (scopeIds && scopeIds.length > 0) {
-    denseMusts.push({
-      key: "memory_scope_id",
-      match: { any: scopeIds },
-    });
-  }
   if (dateRange?.afterMs != null) {
     denseMusts.push({ key: "created_at", range: { gte: dateRange.afterMs } });
   }

package/src/memory/graph/retriever.test.ts

@@ -71,6 +71,7 @@ mock.module("../../providers/provider-send-message.js", () => ({
   extractToolUse: () => null,
 }));
 
+import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { resetDb } from "../db-connection.js";
@@ -81,6 +82,11 @@ import { loadContextMemory, retrieveForTurn } from "./retriever.js";
 import { createNode } from "./store.js";
 import type { NewNode } from "./types.js";
 
+// These tests exercise v1 retrieval. v2 takeover (both `memory-v2-enabled`
+// flag *and* `memory.v2.enabled` schema field) makes `loadContextMemory`
+// short-circuit, so disable the flag here to keep the v1 path under test.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 const TEST_CONFIG: AssistantConfig = { ...DEFAULT_CONFIG };
 
 function makeCapabilityNode(content: string, capId: string): NewNode {