@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -9,7 +9,7 @@ import type {
   RecallSearchContext,
   RecallSearchResult,
 } from "../types.js";
-import { isMemoryV2ReadActive, searchMemoryV2Source } from "./memory-v2.js";
+import { searchMemoryV2Source } from "./memory-v2.js";
 
 const log = getLogger("context-search-memory-source");
 
@@ -23,7 +23,7 @@ export async function searchMemorySource(
     return { evidence: [] };
   }
 
-  if (isMemoryV2ReadActive(context.config)) {
+  if (context.config.memory.v2.enabled) {
     return searchMemoryV2Source(query, context, normalizedLimit);
   }
 
@@ -47,7 +47,6 @@ export async function searchMemorySource(
     const searchResults = await searchGraphNodes(
       queryVector,
       normalizedLimit,
-      [context.memoryScopeId],
       sparseVector,
     );
 

package/src/memory/context-search/sources/pkb.ts

@@ -15,7 +15,6 @@ import type {
   RecallSearchContext,
   RecallSearchResult,
 } from "../types.js";
-import { isMemoryV2ReadActive } from "./memory-v2.js";
 
 const log = getLogger("context-search-pkb-source");
 
@@ -76,7 +75,7 @@ export async function searchPkbSource(
   context: RecallSearchContext,
   limit: number,
 ): Promise<RecallSearchResult> {
-  if (isMemoryV2ReadActive(context.config)) {
+  if (context.config.memory.v2.enabled) {
     return { evidence: [] };
   }
 
@@ -139,7 +138,7 @@ export async function searchPkbSource(
 export function readPkbContextEvidence(
   context: RecallSearchContext,
 ): RecallEvidence[] {
-  if (isMemoryV2ReadActive(context.config)) {
+  if (context.config.memory.v2.enabled) {
     return [];
   }
 

package/src/memory/context-search/types.ts

@@ -24,7 +24,6 @@ export interface RecallEvidence {
 
 export interface RecallSearchContext {
   workingDir: string;
-  memoryScopeId: string;
   conversationId: string;
   config: AssistantConfig;
   signal?: AbortSignal;

package/src/memory/conversation-crud.ts

@@ -115,8 +115,6 @@ export const messageMetadataSchema = z
   })
   .passthrough();
 
-export type MessageMetadata = z.infer<typeof messageMetadataSchema>;
-
 function cloneForkMessageMetadata(
   metadata: string | null,
   sourceMessageId: string,
@@ -444,11 +442,6 @@ export function getConversationSource(conversationId: string): string | null {
   return row?.source ?? null;
 }
 
-export function getConversationMemoryScopeId(conversationId: string): string {
-  const conv = getConversation(conversationId);
-  return conv?.memoryScopeId ?? "default";
-}
-
 /**
  * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
  * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
@@ -912,7 +905,6 @@ export async function addMessage(
   if (!opts?.skipIndexing) {
     try {
       const config = getConfig();
-      const scopeId = getConversationMemoryScopeId(conversationId);
       const parsed = metadata
         ? messageMetadataSchema.safeParse(metadata)
         : null;
@@ -927,7 +919,7 @@ export async function addMessage(
           role: message.role,
           content: message.content,
           createdAt: message.createdAt,
-          scopeId,
+          scopeId: "default",
           provenanceTrustClass,
           automated,
         },
@@ -1027,7 +1019,7 @@ export function hasMessages(conversationId: string): boolean {
   return row !== undefined;
 }
 
-export interface PaginatedMessagesResult {
+interface PaginatedMessagesResult {
   messages: MessageRow[];
   hasMore: boolean;
 }
@@ -1441,12 +1433,12 @@ export function deleteLastExchange(conversationId: string): number {
  * Callers must delete these from the Qdrant collection after the
  * SQLite transaction commits.
  */
-export interface DeletedMemoryIds {
+interface DeletedMemoryIds {
   segmentIds: string[];
   deletedSummaryIds: string[];
 }
 
-export interface WipeConversationResult extends DeletedMemoryIds {
+interface WipeConversationResult extends DeletedMemoryIds {
   cancelledJobCount: number;
 }
 

package/src/memory/db-init.ts

@@ -165,6 +165,7 @@ import {
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
   migrateToolInvocationsMatchedRuleId,
+  migrateTraceEventsCreatedAtIndex,
   migrateUsageDashboardIndexes,
   migrateUsageLlmCallCount,
   migrateVoiceInviteColumns,
@@ -408,6 +409,7 @@ export function initializeDb(): void {
       backfillAppConversationIds();
     },
     migrateScheduleRetryPolicy,
+    migrateTraceEventsCreatedAtIndex,
   ];
 
   // Run each migration step, catching and logging individual failures so one

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

@@ -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,
@@ -45,25 +42,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
@@ -95,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: [] };
   }
 }
 
@@ -167,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
@@ -232,15 +234,26 @@ 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;
 }
 
-/** 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({
@@ -253,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 },
+        })),
+    });
   }
 }
 
@@ -262,42 +291,17 @@ beforeEach(() => {
   testDbHandle = createTestDb();
   qdrantState.queryResponses.dense.length = 0;
   qdrantState.queryResponses.sparse.length = 0;
+  loadContextMemoryMock.mockClear();
+  retrieveForTurnMock.mockClear();
   _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();
@@ -316,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();
@@ -334,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.
@@ -347,13 +352,15 @@ 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 () => {
     // 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();
@@ -380,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();
@@ -404,12 +410,11 @@ 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.
-    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");
 
@@ -422,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>");
@@ -430,14 +437,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 });
+  test("config off → v2 not run on first turn either", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
-    const memory = new ConversationGraphMemory("scope-1", "conv-test-cl-off");
-    const config = makeConfig(true);
+    const memory = new ConversationGraphMemory("conv-test-cl-off");
+    const config = makeConfig(false);
     const messages = makeMessages("first message of the conversation here");
 
     const result = await memory.prepareMemory(
@@ -451,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",
+    );
+  });
+});