@vellumai/assistant 0.7.2 → 0.7.3

package/src/memory/embedding-runtime-manager.ts

@@ -38,10 +38,16 @@ const ONNXRUNTIME_COMMON_VERSION = "1.21.0";
 const TRANSFORMERS_VERSION = "3.8.1";
 const JINJA_VERSION = "0.5.5";
 
-/** Composite version string for cache invalidation. */
-const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}`;
+/**
+ * Composite version string for cache invalidation. Bumping the trailing
+ * `_workers-vN` suffix forces existing installs to regenerate the worker
+ * scripts when the worker IPC contract or spawn-args list changes (without
+ * requiring an `@huggingface/transformers` version bump).
+ */
+const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v2`;
 
 const WORKER_FILENAME = "embed-worker.mjs";
+const RERANK_WORKER_FILENAME = "rerank-worker.mjs";
 
 /** Module-level guard so concurrent in-process calls share one download. */
 const installGuard = new PromiseGuard<void>();
@@ -171,6 +177,101 @@ process.stdin.on('end', () => process.exit(0));
 `;
 }
 
+function generateRerankWorkerScript(): string {
+  // Cross-encoder rerank worker. Loads a sequence-classification model and
+  // scores paired (queries[i], passages[i]) tuples in one batched ONNX
+  // inference call. Mirrors the embed worker's lifecycle (ready signal,
+  // JSON-lines IPC, sequential queue) so LocalRerankBackend can reuse the
+  // same supervisor pattern.
+  //
+  // Request shape: { id, queries: string[], passages: string[] } with
+  // queries.length === passages.length. Each pair is one (query, passage)
+  // tuple; multiple distinct queries can ride in a single batch so the
+  // activation pipeline can score the user-channel and assistant-channel
+  // queries against a shared candidate set in one tokenizer + ONNX call.
+  return `\
+// rerank-worker.mjs — Auto-generated by EmbeddingRuntimeManager
+// Runs in a separate bun process, communicates via JSON-lines over stdin/stdout.
+process.title = 'rerank-worker';
+import {
+  AutoModelForSequenceClassification,
+  AutoTokenizer,
+  env,
+} from '@huggingface/transformers';
+
+const model = process.argv[2];
+const cacheDir = process.argv[3];
+const dtype = process.argv[4] || 'q8';
+if (cacheDir && env) env.cacheDir = cacheDir;
+
+let tokenizer;
+let session;
+try {
+  tokenizer = await AutoTokenizer.from_pretrained(model);
+  session = await AutoModelForSequenceClassification.from_pretrained(model, { dtype });
+  process.stdout.write(JSON.stringify({ type: 'ready' }) + '\\n');
+} catch (err) {
+  process.stdout.write(JSON.stringify({ type: 'error', error: err.message || String(err) }) + '\\n');
+  process.exit(1);
+}
+
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+
+const decoder = new TextDecoder();
+let buffer = '';
+let processing = false;
+const queue = [];
+
+process.stdin.on('data', (chunk) => {
+  buffer += typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+  let idx;
+  while ((idx = buffer.indexOf('\\n')) !== -1) {
+    const line = buffer.slice(0, idx);
+    buffer = buffer.slice(idx + 1);
+    if (line.trim()) queue.push(line);
+  }
+  if (!processing) processQueue();
+});
+
+async function processQueue() {
+  processing = true;
+  while (queue.length > 0) {
+    const line = queue.shift();
+    let req;
+    try { req = JSON.parse(line); } catch { continue; }
+    try {
+      const { id, queries, passages } = req;
+      if (
+        !Array.isArray(queries) || !Array.isArray(passages) ||
+        queries.length !== passages.length || passages.length === 0
+      ) {
+        process.stdout.write(JSON.stringify({ id, scores: [] }) + '\\n');
+        continue;
+      }
+      const inputs = await tokenizer(queries, {
+        text_pair: passages,
+        padding: true,
+        truncation: true,
+        return_tensors: 'pt',
+      });
+      const out = await session(inputs);
+      const logits = out.logits.data;
+      const scores = new Array(passages.length);
+      for (let i = 0; i < passages.length; i++) {
+        scores[i] = sigmoid(Number(logits[i]));
+      }
+      process.stdout.write(JSON.stringify({ id, scores }) + '\\n');
+    } catch (err) {
+      process.stdout.write(JSON.stringify({ id: req?.id, error: err.message || String(err) }) + '\\n');
+    }
+  }
+  processing = false;
+}
+
+process.stdin.on('end', () => process.exit(0));
+`;
+}
+
 // ── Main manager ────────────────────────────────────────────────────
 
 export class EmbeddingRuntimeManager {
@@ -186,8 +287,12 @@ export class EmbeddingRuntimeManager {
     if (!manifest) return false;
     if (manifest.runtimeVersion !== RUNTIME_VERSION) return false;
 
-    // Verify the worker script exists and a bun binary is available
-    return existsSync(this.getWorkerPath()) && this.getBunPath() !== undefined;
+    // Verify both worker scripts exist and a bun binary is available
+    return (
+      existsSync(this.getWorkerPath()) &&
+      existsSync(this.getRerankWorkerPath()) &&
+      this.getBunPath() !== undefined
+    );
   }
 
   /** Path to the embed worker script. */
@@ -195,6 +300,11 @@ export class EmbeddingRuntimeManager {
     return join(this.baseDir, WORKER_FILENAME);
   }
 
+  /** Path to the rerank worker script. */
+  getRerankWorkerPath(): string {
+    return join(this.baseDir, RERANK_WORKER_FILENAME);
+  }
+
   /**
    * Find a usable bun binary.
    * Delegates to the shared bun-runtime helper, also checking
@@ -375,8 +485,12 @@ export class EmbeddingRuntimeManager {
         ].join("\n"),
       );
 
-      // Step 4: Write embed worker script
+      // Step 4: Write embed + rerank worker scripts
       writeFileSync(join(tmpDir, WORKER_FILENAME), generateWorkerScript());
+      writeFileSync(
+        join(tmpDir, RERANK_WORKER_FILENAME),
+        generateRerankWorkerScript(),
+      );
 
       // Step 5: Write version manifest
       const manifest: VersionManifest = {

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();
 });
 
@@ -347,6 +352,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     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 () => {
@@ -409,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");
 
@@ -430,13 +438,16 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     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) {

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

@@ -38,17 +38,13 @@ 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
@@ -66,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 } });
@@ -120,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 {