@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -1,19 +1,14 @@
 /**
- * Tests for `handleRemember` flag-routing between v1 (PKB) and v2 (memory/).
+ * Tests for `handleRemember` routing between v1 (PKB) and v2 (memory/).
  *
- * Verifies:
- *   - Flag on  → writes go to `memory/buffer.md` + `memory/archive/<today>.md`
- *                and NO PKB re-index job is enqueued.
- *   - Flag off → existing PKB path is unchanged (writes to `pkb/buffer.md`
- *                + `pkb/archive/<today>.md`, both files are re-indexed).
- *   - Archive filename uses today's local date.
+ * Routing follows `config.memory.v2.enabled`: when true, writes go to
+ * memory/; otherwise they fall back to v1 PKB.
  */
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -62,11 +57,13 @@ afterAll(() => {
 // Imports are deferred to after the env var is set so any internal use of
 // `getWorkspaceDir()` resolves to the tmpdir.
 const { handleRemember } = await import("../tool-handlers.js");
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
 const { applyNestedDefaults } = await import("../../../config/loader.js");
 
 const CONFIG = applyNestedDefaults({});
+const CONFIG_V2_OFF = {
+  ...CONFIG,
+  memory: { ...CONFIG.memory, v2: { ...CONFIG.memory.v2, enabled: false } },
+};
 
 beforeEach(() => {
   enqueueCalls.length = 0;
@@ -76,10 +73,6 @@ beforeEach(() => {
   rmSync(join(tmpWorkspace, "memory"), { recursive: true, force: true });
 });
 
-afterEach(() => {
-  _setOverridesForTesting({});
-});
-
 function todaysArchiveBasename(now: Date = new Date()): string {
   const yyyy = now.getFullYear();
   const mm = String(now.getMonth() + 1).padStart(2, "0");
@@ -87,11 +80,7 @@ function todaysArchiveBasename(now: Date = new Date()): string {
   return `${yyyy}-${mm}-${dd}.md`;
 }
 
-describe("handleRemember — memory-v2 flag on", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-  });
-
+describe("handleRemember — memory.v2.enabled on", () => {
   test("writes to memory/buffer.md and memory/archive/<today>.md", () => {
     const result = handleRemember(
       { content: "Alice prefers VS Code over Vim" },
@@ -175,17 +164,13 @@ describe("handleRemember — memory-v2 flag on", () => {
   });
 });
 
-describe("handleRemember — memory-v2 flag off (v1 PKB path)", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-  });
-
+describe("handleRemember — memory.v2.enabled off (v1 PKB path)", () => {
   test("writes to pkb/buffer.md and pkb/archive/<today>.md", () => {
     const result = handleRemember(
       { content: "v1 path still works" },
       "conv-v1-1",
       "default",
-      CONFIG,
+      CONFIG_V2_OFF,
     );
 
     expect(result.success).toBe(true);
@@ -206,7 +191,7 @@ describe("handleRemember — memory-v2 flag off (v1 PKB path)", () => {
       { content: "index me" },
       "conv-v1-2",
       "default",
-      CONFIG,
+      CONFIG_V2_OFF,
     );
 
     expect(result.success).toBe(true);

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

@@ -8,7 +8,6 @@
 
 import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { estimateTextTokens } from "../../context/token-estimator.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
@@ -23,6 +22,11 @@ import { getDb } from "../db-connection.js";
 import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
+import {
+  evictCompactedTurns as evictCompactedTurnsV2,
+  hydrate as hydrateV2State,
+  save as saveV2State,
+} from "../v2/activation-store.js";
 import {
   injectMemoryV2Block,
   type InjectMemoryV2Mode,
@@ -62,14 +66,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 +149,6 @@ export class ConversationGraphMemory {
       const db = getDb();
       const baseWhere = and(
         eq(memorySummaries.scope, "conversation"),
-        eq(memorySummaries.scopeId, this.scopeId),
         ne(memorySummaries.scopeKey, this.conversationId),
       );
 
@@ -209,11 +210,33 @@ export class ConversationGraphMemory {
    * Notify that context compaction just happened.
    * On the next turn, we'll re-run full context load.
    */
-  onCompacted(compactedMessageCount: number): void {
+  async onCompacted(compactedMessageCount: number): Promise<void> {
     // Evict everything — compaction summarized all prior turns.
     // The tracker can't know exactly which turns were compacted,
     // so we conservatively clear everything and reload.
-    this.tracker.evictCompactedTurns(this.tracker.getTurn());
+    const upToTurn = this.tracker.getTurn();
+    this.tracker.evictCompactedTurns(upToTurn);
+
+    // Mirror the eviction on the v2 activation row: the cached `<memory>`
+    // attachments those slugs lived on are gone, but `everInjected` would
+    // otherwise keep them deduped from per-turn deltas forever.
+    try {
+      const db = getDb();
+      const state = await hydrateV2State(db, this.conversationId);
+      if (state) {
+        await saveV2State(
+          db,
+          this.conversationId,
+          evictCompactedTurnsV2(state, upToTurn),
+        );
+      }
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to evict v2 activation state on compaction (non-fatal)",
+      );
+    }
+
     this.needsReload = true;
     log.info(
       { compactedMessageCount },
@@ -385,29 +408,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 +420,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 +434,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 +557,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 +577,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 +653,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 workspace config
+   * (`memory.v2.enabled`) is 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,15 +670,13 @@ export class ConversationGraphMemory {
     mode: InjectMemoryV2Mode,
     userMessage: string,
     assistantMessage: string,
+    signal: AbortSignal,
   ): Promise<{
     routed: boolean;
     runMessages: Message[];
     injectedBlockText: string | null;
   }> {
-    if (
-      !isAssistantFeatureFlagEnabled("memory-v2-enabled", config) ||
-      !config.memory.v2.enabled
-    ) {
+    if (!config.memory.v2.enabled) {
       return { routed: false, runMessages: messages, injectedBlockText: null };
     }
 
@@ -683,6 +693,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

@@ -2,6 +2,13 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
 
+// This test exercises the v1 graph search path. `config.memory.v2.enabled`
+// (default `true`) makes graph-search short-circuit to keep traffic off
+// the legacy collection — force it off so the v1 path stays under test.
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: { v2: { enabled: false } } }),
+}));
+
 mock.module("../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
@@ -64,7 +71,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 +87,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 +100,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 +108,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 +118,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

@@ -5,7 +5,6 @@
 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";
@@ -38,23 +37,19 @@ 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
+  // v2 owns the read path when enabled. 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 (getConfig().memory.v2.enabled) return [];
 
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
@@ -66,21 +61,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 +106,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

@@ -81,7 +81,16 @@ import { loadContextMemory, retrieveForTurn } from "./retriever.js";
 import { createNode } from "./store.js";
 import type { NewNode } from "./types.js";
 
-const TEST_CONFIG: AssistantConfig = { ...DEFAULT_CONFIG };
+// These tests exercise v1 retrieval. `memory.v2.enabled` (default `true`)
+// makes `loadContextMemory` short-circuit, so disable it here to keep the
+// v1 path under test.
+const TEST_CONFIG: AssistantConfig = {
+  ...DEFAULT_CONFIG,
+  memory: {
+    ...DEFAULT_CONFIG.memory,
+    v2: { ...DEFAULT_CONFIG.memory.v2, enabled: false },
+  },
+};
 
 function makeCapabilityNode(content: string, capId: string): NewNode {
   const now = Date.now();
@@ -401,8 +410,10 @@ describe("loadContextMemory — dual-query capability ranking", () => {
 
   // Build a config where capabilityReserve=1 so the ranking code actually
   // prunes (it only prunes when capabilityNodes.length > capabilityReserve).
+  // memory.v2.enabled=false to keep the v1 retrieval path under test.
   const DUAL_QUERY_CONFIG: AssistantConfig = structuredClone(DEFAULT_CONFIG);
   DUAL_QUERY_CONFIG.memory.retrieval.injection.contextLoad.capabilityReserve = 1;
+  DUAL_QUERY_CONFIG.memory.v2.enabled = false;
 
   // Keyword-routed embed: any text that contains a topic keyword returns a
   // one-hot vector identifying that topic. Anything else falls back to a

package/src/memory/graph/retriever.ts

@@ -14,7 +14,6 @@ import {
 } from "../../providers/provider-send-message.js";
 import type { ContentBlock, ImageContent } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { embedWithRetry } from "../embed.js";
 import {
   generateSparseEmbedding,
@@ -351,7 +350,7 @@ async function dedupCrossCategory(
 // Context load — conversation start
 // ---------------------------------------------------------------------------
 
-export interface ContextLoadOpts {
+interface ContextLoadOpts {
   /** Scope for memory isolation. */
   scopeId: string;
   /** Recent conversation summaries (used as retrieval queries). */
@@ -373,7 +372,7 @@ export interface ContextLoadOpts {
   userQuery?: string;
 }
 
-export interface ContextLoadResult {
+interface ContextLoadResult {
   nodes: ScoredNode[];
   serendipityNodes: ScoredNode[];
   triggeredNodes: TriggeredResult[];
@@ -426,12 +425,12 @@ export interface ContextLoadResult {
 export async function loadContextMemory(
   opts: ContextLoadOpts,
 ): Promise<ContextLoadResult> {
-  // v2 owns the read path when both gates are on. The v1 collection is in
-  // active retirement and querying it can OOM-crash Qdrant via a corrupted
-  // sparse segment, so we skip the embedding work and downstream searches
+  // v2 owns the read path when enabled. The v1 collection is in active
+  // retirement and querying it can OOM-crash Qdrant via a corrupted sparse
+  // segment, so we skip the embedding work and downstream searches
   // entirely. Caller (`runContextLoad`) sees zero nodes and routes to the
   // v2 activation pipeline.
-  if (isMemoryV2ReadActive(opts.config)) {
+  if (opts.config.memory.v2.enabled) {
     return {
       nodes: [],
       serendipityNodes: [],
@@ -525,7 +524,6 @@ export async function loadContextMemory(
       const results = await searchGraphNodes(
         queryVector,
         maxNodes * 3,
-        [opts.scopeId],
         sparseVector,
       );
       for (const r of results) {
@@ -548,7 +546,6 @@ export async function loadContextMemory(
       const results = await searchGraphNodes(
         userQueryVector,
         maxNodes * 3,
-        [opts.scopeId],
         undefined,
       );
       for (const r of results) {
@@ -873,7 +870,7 @@ export async function loadContextMemory(
 // Per-turn retrieval — mid-conversation injection
 // ---------------------------------------------------------------------------
 
-export interface TurnRetrievalOpts {
+interface TurnRetrievalOpts {
   /** The assistant's last message content. */
   assistantLastMessage: string;
   /** The user's last message content. */
@@ -886,7 +883,7 @@ export interface TurnRetrievalOpts {
   signal?: AbortSignal;
 }
 
-export interface TurnRetrievalResult {
+interface TurnRetrievalResult {
   /** New nodes to inject (not already in context). */
   nodes: ScoredNode[];
   /** Serendipity picks included in nodes. */
@@ -1007,9 +1004,7 @@ export async function retrieveForTurn(
           }
           const imgVector = imgResult.vectors[0];
           if (imgVector) {
-            const imgResults = await searchGraphNodes(imgVector, 40, [
-              opts.scopeId,
-            ]);
+            const imgResults = await searchGraphNodes(imgVector, 40);
             for (const r of imgResults) {
               const current = allCandidateIds.get(r.nodeId) ?? 0;
               allCandidateIds.set(r.nodeId, Math.max(current, r.score));
@@ -1097,7 +1092,7 @@ export async function retrieveForTurn(
       queryEmbeddings = embedResults.vectors;
 
       const searchPromises = queryEmbeddings.map((vec) =>
-        searchGraphNodes(vec, 40, [opts.scopeId]),
+        searchGraphNodes(vec, 40),
       );
       const searchResults = await Promise.all(searchPromises);