@vellumai/assistant 0.7.3 → 0.8.0

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

@@ -1,18 +1,16 @@
 /**
  * Tests for the v2 routing wired into `ConversationGraphMemory.prepareMemory`.
  *
- * The wiring layer at `conversation-graph-memory.ts` reads two signals to
- * decide whether to swap v1's injection step for the v2 activation pipeline:
+ * 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.
  *
- *   1. The `memory-v2-enabled` feature flag (`isAssistantFeatureFlagEnabled`).
- *   2. The workspace config value `memory.v2.enabled`.
- *
- * Both must be true for v2 to take over. This file uses the *real*
- * `injectMemoryV2Block` and stubs only the lower-level deps (Qdrant client,
- * embedding backend) the way `memory/v2/__tests__/injection.test.ts` does —
- * mocking `injection.js` itself would clobber that sibling test when both
- * files run in the same `bun test` invocation, since `mock.module` is
- * process-global. Avoiding the mock keeps the suite hermetic in either order.
+ * This file uses the *real* `injectMemoryV2Block` and stubs only the
+ * lower-level deps (Qdrant client, embedding backend) the way
+ * `memory/v2/__tests__/injection.test.ts` does — mocking `injection.js`
+ * itself would clobber that sibling test when both files run in the same
+ * `bun test` invocation, since `mock.module` is process-global. Avoiding
+ * the mock keeps the suite hermetic in either order.
  */
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -20,7 +18,6 @@ import { join } from "node:path";
 import { Database } from "bun:sqlite";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -98,9 +95,11 @@ class MockQdrantClient {
     _name: string,
     params: { using: string; limit: number; filter?: unknown },
   ) {
-    const queue =
-      qdrantState.queryResponses[params.using as "dense" | "sparse"];
-    return queue.shift() ?? { points: [] };
+    // The four-channel hybrid query fires body-dense, body-sparse,
+    // summary-dense, summary-sparse in order; both dense channels share
+    // the dense queue and both sparse channels share the sparse queue.
+    const channel = params.using.endsWith("sparse") ? "sparse" : "dense";
+    return qdrantState.queryResponses[channel].shift() ?? { points: [] };
   }
 }
 
@@ -170,14 +169,14 @@ import type { DrizzleDb } from "../../db-connection.js";
 
 const { ConversationGraphMemory } =
   await import("../conversation-graph-memory.js");
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
 const { applyNestedDefaults } = await import("../../../config/loader.js");
 const { getSqliteFrom } = await import("../../db-connection.js");
 const { migrateActivationState } =
   await import("../../migrations/232-activation-state.js");
 const schema = await import("../../schema.js");
 const { _resetMemoryV2QdrantForTests } = await import("../../v2/qdrant.js");
+const { hydrate: hydrateActivationState } =
+  await import("../../v2/activation-store.js");
 
 // The wiring layer calls `getDb()` to fetch the SQLite handle. We mock
 // only that one export and spread the real module so unrelated callers
@@ -240,10 +239,21 @@ function makeMemory(): InstanceType<typeof ConversationGraphMemory> {
   return m;
 }
 
-/** Stage one set of dense/sparse hits for each channel of the activation
- *  pipeline (1 candidate query + 3 simBatch channels). */
+/** Stage one set of body and summary dense/sparse hits for each channel of
+ *  the activation pipeline (1 candidate query + 3 simBatch channels). Each
+ *  `hybridQueryConceptPages` call now fires four sub-queries (body-dense,
+ *  body-sparse, summary-dense, summary-sparse) so we push four entries per
+ *  channel iteration. Hits without `summary*Score` set produce empty point
+ *  lists for the summary channels — fine for tests that only care about body
+ *  scoring. */
 function stageTurn(
-  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+  hits: Array<{
+    slug: string;
+    denseScore?: number;
+    sparseScore?: number;
+    summaryDenseScore?: number;
+    summarySparseScore?: number;
+  }>,
 ): void {
   for (let i = 0; i < 4; i++) {
     qdrantState.queryResponses.dense.push({
@@ -256,6 +266,22 @@ function stageTurn(
         .filter((h) => h.sparseScore !== undefined)
         .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
     });
+    qdrantState.queryResponses.dense.push({
+      points: hits
+        .filter((h) => h.summaryDenseScore !== undefined)
+        .map((h) => ({
+          score: h.summaryDenseScore,
+          payload: { slug: h.slug },
+        })),
+    });
+    qdrantState.queryResponses.sparse.push({
+      points: hits
+        .filter((h) => h.summarySparseScore !== undefined)
+        .map((h) => ({
+          score: h.summarySparseScore,
+          payload: { slug: h.slug },
+        })),
+    });
   }
 }
 
@@ -270,39 +296,12 @@ beforeEach(() => {
   _resetMemoryV2QdrantForTests();
 });
 
-afterEach(() => {
-  _setOverridesForTesting({});
-});
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
 describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)", () => {
-  test("flag off → v2 not run, messages unchanged", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
-
-    const memory = makeMemory();
-    const config = makeConfig(true);
-    const messages = makeMessages();
-
-    const result = await memory.prepareMemory(
-      messages,
-      config,
-      new AbortController().signal,
-      noopEvent,
-    );
-
-    expect(result.mode).toBe("per-turn");
-    expect(result.injectedBlockText).toBeNull();
-    // No v2 block prepended — the v1 retriever returned zero nodes so the
-    // user message is exactly the input.
-    expect(result.runMessages).toEqual(messages);
-  });
-
-  test("flag on + config off → v2 not run, messages unchanged", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config off → v2 not run, messages unchanged", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = makeMemory();
@@ -321,8 +320,7 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(result.runMessages).toEqual(messages);
   });
 
-  test("flag on + config on → v2 block prepended, mode is per-turn", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config on → v2 block prepended, mode is per-turn", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = makeMemory();
@@ -339,7 +337,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(result.mode).toBe("per-turn");
     expect(result.injectedBlockText).not.toBeNull();
     expect(result.injectedBlockText).not.toContain("<memory>");
-    expect(result.injectedBlockText).toContain("### alice-vscode");
+    expect(result.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
 
     // The leading content block on the user message is the v2 block,
     // wrapped exactly once.
@@ -361,7 +361,6 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     // 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();
@@ -388,11 +387,10 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     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");
+    expect(firstBlock.text).toContain("# memory/concepts/alice-vscode.md");
   });
 
-  test("flag on + config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
     // No `stageTurn` call — every channel returns `{ points: [] }` so the
     // candidate set is empty and `injectMemoryV2Block` returns block=null.
     const memory = makeMemory();
@@ -412,8 +410,7 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
 });
 
 describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load path)", () => {
-  test("flag on + config on → v2 fires with mode=context-load", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config on → v2 fires with mode=context-load", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     // Fresh memory → initialized=false → runContextLoad branch.
@@ -430,7 +427,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
 
     expect(result.mode).toBe("context-load");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("### alice-vscode");
+    expect(result.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
     // injectedBlockText is the unwrapped inner content; the wrapper is
     // applied at injection time on the run message.
     expect(result.injectedBlockText).not.toContain("<memory>");
@@ -443,12 +442,11 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     expect(loadContextMemoryMock).not.toHaveBeenCalled();
   });
 
-  test("flag off → v2 not run on first turn either", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
+  test("config off → v2 not run on first turn either", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = new ConversationGraphMemory("conv-test-cl-off");
-    const config = makeConfig(true);
+    const config = makeConfig(false);
     const messages = makeMessages("first message of the conversation here");
 
     const result = await memory.prepareMemory(
@@ -462,3 +460,48 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     expect(result.injectedBlockText).toBeNull();
   });
 });
+
+describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () => {
+  test("clears everInjected so a previously-injected slug can re-attach", async () => {
+    // Without this wiring, `selectInjections` keeps subtracting the slug from
+    // every per-turn delta even though compaction discarded the cached
+    // `<memory>` attachment that previously made it visible.
+    const conversationId = "conv-test-evict";
+    const memory = new ConversationGraphMemory(conversationId);
+    const config = makeConfig(true);
+
+    // Turn 1 — context-load fires (initialized=false), injecting alice-vscode.
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+    const initial = await memory.prepareMemory(
+      makeMessages("Tell me about Alice's editor preferences"),
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(initial.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
+
+    const before = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(before?.everInjected.map((e) => e.slug)).toContain("alice-vscode");
+
+    await memory.onCompacted(1);
+
+    const after = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(after?.everInjected).toEqual([]);
+
+    // Turn 2 — same Qdrant relevance. With everInjected cleared the slug
+    // should appear again in the injection block (re-attached on the new
+    // user message after compaction).
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+    const next = await memory.prepareMemory(
+      makeMessages("And what about Alice's editor again?"),
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(next.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
+  });
+});

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,
@@ -206,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 },
@@ -627,8 +653,8 @@ export class ConversationGraphMemory {
   }
 
   /**
-   * Run 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 falls through to the legacy v1
@@ -650,10 +676,7 @@ export class ConversationGraphMemory {
     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 };
     }
 

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

@@ -1,12 +1,13 @@
 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 });
+// 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(),

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";
@@ -46,11 +45,11 @@ export async function searchGraphNodes(
   sparseVector?: QdrantSparseVector,
   dateRange?: { afterMs?: number; beforeMs?: number },
 ): 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");

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

@@ -71,7 +71,6 @@ 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";
@@ -82,12 +81,16 @@ 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 };
+// 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();
@@ -407,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,
@@ -426,12 +425,12 @@ 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: [],

package/src/memory/graph/tool-handlers.ts

@@ -2,14 +2,13 @@
 // Memory Tool handlers
 //
 // remember: save facts to the PKB (buffer.md + daily archive) under the v1
-// path, or to memory/buffer.md + memory/archive/<today>.md when the
-// `memory-v2-enabled` feature flag is on.
+// path, or to memory/buffer.md + memory/archive/<today>.md when memory v2 is
+// active.
 // ---------------------------------------------------------------------------
 
 import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -46,7 +45,7 @@ export function handleRemember(
   const now = new Date();
   const entry = formatRememberEntry(input.content.trim(), now);
 
-  if (isAssistantFeatureFlagEnabled("memory-v2-enabled", config)) {
+  if (config.memory.v2.enabled) {
     appendBufferAndArchive({
       rootDir: join(workspaceDir, "memory"),
       entry,

package/src/memory/graph/tools.ts

@@ -56,10 +56,10 @@ export const graphRecallDefinition: ToolDefinition = {
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
  * `buffer.md` (immediately available in the next conversation) and the daily
- * archive (permanent date-indexed record). With the `memory-v2-enabled`
- * feature flag on, writes go under `memory/`; otherwise they go under
- * `pkb/`. Consolidation of the buffer into longer-form storage runs as a
- * separate periodic job in both modes.
+ * archive (permanent date-indexed record). When `memory.v2.enabled` is true,
+ * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
+ * of the buffer into longer-form storage runs as a separate periodic job in
+ * both modes.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",

package/src/memory/indexer.ts

@@ -9,7 +9,6 @@ import { getLogger } from "../util/logger.js";
 import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
-import { isMemoryV2ReadActive } from "./context-search/sources/memory-v2.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
@@ -190,7 +189,7 @@ export async function indexMessageNow(
       }
 
       const v2Config =
-        triggerConfig != null && isMemoryV2ReadActive(triggerConfig)
+        triggerConfig != null && triggerConfig.memory.v2.enabled
           ? triggerConfig
           : null;