@vellumai/assistant 0.7.3 → 0.8.0

package/src/memory/v2/__tests__/qdrant.test.ts

@@ -27,10 +27,39 @@ mock.module("../../qdrant-client.js", () => ({
 // records every call and lets each test program the next response.
 type MockPoint = {
   id: string;
-  vector: { dense: number[]; sparse: { indices: number[]; values: number[] } };
+  vector: {
+    dense: number[];
+    sparse: { indices: number[]; values: number[] };
+    summary_dense?: number[];
+    summary_sparse?: { indices: number[]; values: number[] };
+  };
   payload: { slug: string; updated_at: number };
 };
 
+type MockCollectionInfo = {
+  config: {
+    params: {
+      vectors?: Record<string, { size: number }> | { size: number };
+      sparse_vectors?: Record<string, unknown>;
+    };
+  };
+};
+
+const FULL_SCHEMA_INFO: MockCollectionInfo = {
+  config: {
+    params: {
+      vectors: {
+        dense: { size: 384 },
+        summary_dense: { size: 384 },
+      },
+      sparse_vectors: {
+        sparse: {},
+        summary_sparse: {},
+      },
+    },
+  },
+};
+
 const state = {
   collectionExistsBeforeCreate: false,
   collectionExistsCalls: 0,
@@ -39,6 +68,10 @@ const state = {
   createIndexCalls: [] as Array<{ field_name: string; field_schema: string }>,
   upsertCalls: [] as Array<{ wait: boolean; points: MockPoint[] }>,
   deleteCalls: [] as Array<{ wait: boolean; points: string[] }>,
+  // Tracks `client.deleteCollection(name)` calls (distinct from `delete()`,
+  // which targets points). The schema-drift recreate path drops the
+  // collection entirely and we want to assert it ran exactly once.
+  deleteCollectionCalls: [] as string[],
   queryCalls: [] as Array<{
     using: string;
     query: unknown;
@@ -55,6 +88,17 @@ const state = {
     }>,
   },
   createCollectionThrows: null as Error | null,
+  // Schema returned by `client.getCollection`. Tests that exercise the
+  // drift path point this at a partial schema; the default mirrors a fully
+  // migrated collection so the no-drift path is the silent default.
+  getCollectionInfo: FULL_SCHEMA_INFO as MockCollectionInfo,
+  getCollectionThrows: null as Error | null,
+  getCollectionCalls: 0,
+  // Point count returned by `client.count`. Used by `countConceptPagePoints`
+  // which the lifecycle hook reads for the empty-after-create recovery path.
+  countResult: 0,
+  countThrows: null as Error | null,
+  countCalls: 0,
   // Throw queue for upsert: first call shifts and throws if non-null;
   // subsequent calls succeed once the queue is exhausted.
   upsertThrowQueue: [] as Array<Error | null>,
@@ -66,13 +110,29 @@ class MockQdrantClient {
     state.collectionExistsCalls++;
     return { exists: state.collectionExistsBeforeCreate };
   }
+  async getCollection(_name: string) {
+    state.getCollectionCalls++;
+    if (state.getCollectionThrows) throw state.getCollectionThrows;
+    return state.getCollectionInfo;
+  }
   async createCollection(_name: string, params: unknown) {
     state.createCollectionCalls++;
     state.createCollectionParams = params;
     if (state.createCollectionThrows) throw state.createCollectionThrows;
     state.collectionExistsBeforeCreate = true;
+    state.getCollectionInfo = FULL_SCHEMA_INFO;
+    return {};
+  }
+  async deleteCollection(name: string) {
+    state.deleteCollectionCalls.push(name);
+    state.collectionExistsBeforeCreate = false;
     return {};
   }
+  async count(_name: string, _opts: { exact: boolean }) {
+    state.countCalls++;
+    if (state.countThrows) throw state.countThrows;
+    return { count: state.countResult };
+  }
   async createPayloadIndex(
     _name: string,
     params: { field_name: string; field_schema: string },
@@ -102,7 +162,14 @@ class MockQdrantClient {
     },
   ) {
     state.queryCalls.push(params);
-    const queue = state.queryResponses[params.using as "dense" | "sparse"];
+    // Both `dense` and `summary_dense` consume from the dense queue (and
+    // similarly for sparse). The four-channel hybrid query fires them in
+    // order: body-dense, body-sparse, summary-dense, summary-sparse — so
+    // queue order matches call order.
+    const queue =
+      state.queryResponses[
+        params.using.endsWith("sparse") ? "sparse" : "dense"
+      ];
     return queue.shift() ?? { points: [] };
   }
 }
@@ -116,6 +183,7 @@ const {
   upsertConceptPageEmbedding,
   deleteConceptPageEmbedding,
   hybridQueryConceptPages,
+  countConceptPagePoints,
   MEMORY_V2_COLLECTION,
   _resetMemoryV2QdrantForTests,
 } = await import("../qdrant.js");
@@ -128,10 +196,17 @@ function resetState(): void {
   state.createIndexCalls.length = 0;
   state.upsertCalls.length = 0;
   state.deleteCalls.length = 0;
+  state.deleteCollectionCalls.length = 0;
   state.queryCalls.length = 0;
   state.queryResponses.dense.length = 0;
   state.queryResponses.sparse.length = 0;
   state.createCollectionThrows = null;
+  state.getCollectionInfo = FULL_SCHEMA_INFO;
+  state.getCollectionThrows = null;
+  state.getCollectionCalls = 0;
+  state.countResult = 0;
+  state.countThrows = null;
+  state.countCalls = 0;
   state.upsertThrowQueue.length = 0;
   _resetMemoryV2QdrantForTests();
 }
@@ -140,7 +215,7 @@ describe("memory v2 qdrant — collection lifecycle", () => {
   beforeEach(resetState);
   afterEach(resetState);
 
-  test("creates the collection with named dense + sparse vectors", async () => {
+  test("creates the collection with named dense + sparse vectors (body and summary)", async () => {
     state.collectionExistsBeforeCreate = false;
 
     await ensureConceptPageCollection();
@@ -149,8 +224,12 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     const params = state.createCollectionParams as {
       vectors: {
         dense: { size: number; distance: string; on_disk: boolean };
+        summary_dense: { size: number; distance: string; on_disk: boolean };
+      };
+      sparse_vectors: {
+        sparse: Record<string, unknown>;
+        summary_sparse: Record<string, unknown>;
       };
-      sparse_vectors: { sparse: Record<string, unknown> };
       hnsw_config: { on_disk: boolean; m: number; ef_construct: number };
       on_disk_payload: boolean;
     };
@@ -159,7 +238,14 @@ describe("memory v2 qdrant — collection lifecycle", () => {
       distance: "Cosine",
       on_disk: true,
     });
+    // Summary side mirrors body so the activation pipeline can fuse symmetrically.
+    expect(params.vectors.summary_dense).toEqual({
+      size: 384,
+      distance: "Cosine",
+      on_disk: true,
+    });
     expect(params.sparse_vectors.sparse).toEqual({});
+    expect(params.sparse_vectors.summary_sparse).toEqual({});
     expect(params.hnsw_config).toEqual({
       on_disk: true,
       m: 16,
@@ -219,6 +305,115 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     // expected to have created it (it ran the same code).
     expect(state.createIndexCalls).toEqual([]);
   });
+
+  test("detects missing summary_dense / summary_sparse on an existing collection and recreates", async () => {
+    // Pre-#29823 schema: only body channels, no summary_*.
+    state.collectionExistsBeforeCreate = true;
+    state.getCollectionInfo = {
+      config: {
+        params: {
+          vectors: { dense: { size: 384 } },
+          sparse_vectors: { sparse: {} },
+        },
+      },
+    };
+
+    const result = await ensureConceptPageCollection();
+
+    // Drift path probed once, dropped the collection once, and recreated
+    // with the full four-vector schema (the create-success branch resets
+    // `getCollectionInfo` to FULL_SCHEMA_INFO so a follow-up probe agrees).
+    expect(state.getCollectionCalls).toBe(1);
+    expect(state.deleteCollectionCalls).toEqual([MEMORY_V2_COLLECTION]);
+    expect(state.createCollectionCalls).toBe(1);
+    expect(result).toEqual({ migrated: true });
+
+    // Recreated schema carries summary_dense + summary_sparse.
+    const params = state.createCollectionParams as {
+      vectors: Record<string, unknown>;
+      sparse_vectors: Record<string, unknown>;
+    };
+    expect(params.vectors.summary_dense).toBeDefined();
+    expect(params.sparse_vectors.summary_sparse).toBeDefined();
+  });
+
+  test("leaves a fully migrated collection untouched", async () => {
+    // Default `getCollectionInfo` is FULL_SCHEMA_INFO — already migrated.
+    state.collectionExistsBeforeCreate = true;
+
+    const result = await ensureConceptPageCollection();
+
+    expect(state.getCollectionCalls).toBe(1);
+    expect(state.deleteCollectionCalls).toEqual([]);
+    expect(state.createCollectionCalls).toBe(0);
+    expect(result).toEqual({ migrated: false });
+  });
+
+  test("getCollection failure is treated as compatible (no destructive recreate)", async () => {
+    state.collectionExistsBeforeCreate = true;
+    state.getCollectionThrows = new Error("transient REST error");
+
+    const result = await ensureConceptPageCollection();
+
+    expect(state.getCollectionCalls).toBe(1);
+    expect(state.deleteCollectionCalls).toEqual([]);
+    expect(state.createCollectionCalls).toBe(0);
+    expect(result).toEqual({ migrated: false });
+  });
+
+  test("concurrent ensure during a schema rebuild only deletes/creates once", async () => {
+    state.collectionExistsBeforeCreate = true;
+    state.getCollectionInfo = {
+      config: {
+        params: {
+          vectors: { dense: { size: 384 } },
+          sparse_vectors: { sparse: {} },
+        },
+      },
+    };
+
+    const results = await Promise.all([
+      ensureConceptPageCollection(),
+      ensureConceptPageCollection(),
+      ensureConceptPageCollection(),
+    ]);
+
+    expect(state.deleteCollectionCalls).toEqual([MEMORY_V2_COLLECTION]);
+    expect(state.createCollectionCalls).toBe(1);
+    // All three concurrent callers see the same migrated signal so any one
+    // of them is safe to enqueue the reembed (the lifecycle hook is the
+    // single producer in practice).
+    expect(results).toEqual([
+      { migrated: true },
+      { migrated: true },
+      { migrated: true },
+    ]);
+  });
+});
+
+describe("memory v2 qdrant — point count", () => {
+  beforeEach(resetState);
+  afterEach(resetState);
+
+  test("returns the approximate Qdrant count for the v2 collection", async () => {
+    state.collectionExistsBeforeCreate = true;
+    state.countResult = 1185;
+
+    const count = await countConceptPagePoints();
+
+    expect(count).toBe(1185);
+    expect(state.countCalls).toBe(1);
+  });
+
+  test("returns 0 when the count call fails (treated as needs-reembed)", async () => {
+    state.collectionExistsBeforeCreate = true;
+    state.countThrows = new Error("Qdrant unreachable");
+
+    const count = await countConceptPagePoints();
+
+    expect(count).toBe(0);
+    expect(state.countCalls).toBe(1);
+  });
 });
 
 describe("memory v2 qdrant — upsert", () => {
@@ -249,12 +444,67 @@ describe("memory v2 qdrant — upsert", () => {
       indices: [1, 2],
       values: [0.5, 0.5],
     });
+    // No summary vectors when caller didn't pass them — Qdrant accepts a
+    // partial named-vector subset, and pages without a frontmatter summary
+    // legitimately have nothing to embed on the summary side.
+    const vectorRecord = point.vector as unknown as Record<string, unknown>;
+    expect(vectorRecord.summary_dense).toBeUndefined();
+    expect(vectorRecord.summary_sparse).toBeUndefined();
     // Point ID is a UUID-shaped string derived from the slug.
     expect(point.id).toMatch(
       /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
     );
   });
 
+  test("upserts summary vectors alongside body vectors when both are provided", async () => {
+    state.collectionExistsBeforeCreate = true;
+
+    await upsertConceptPageEmbedding({
+      slug: "summarized-page",
+      dense: [0.1, 0.2, 0.3],
+      sparse: { indices: [1, 2], values: [0.5, 0.5] },
+      summary: {
+        dense: [0.4, 0.5, 0.6],
+        sparse: { indices: [3, 4], values: [0.7, 0.7] },
+      },
+      updatedAt: 1714000000000,
+    });
+
+    expect(state.upsertCalls).toHaveLength(1);
+    const [point] = state.upsertCalls[0].points;
+    const vectorRecord = point.vector as unknown as Record<string, unknown>;
+    expect(vectorRecord.dense).toEqual([0.1, 0.2, 0.3]);
+    expect(vectorRecord.sparse).toEqual({
+      indices: [1, 2],
+      values: [0.5, 0.5],
+    });
+    expect(vectorRecord.summary_dense).toEqual([0.4, 0.5, 0.6]);
+    expect(vectorRecord.summary_sparse).toEqual({
+      indices: [3, 4],
+      values: [0.7, 0.7],
+    });
+  });
+
+  test("omits summary vectors when the summary block is undefined", async () => {
+    // The grouped-shape signature enforces summary as a paired { dense, sparse }
+    // block; passing `undefined` (or omitting it) leaves the summary vectors off
+    // the point entirely so query-time fusion stays symmetric.
+    state.collectionExistsBeforeCreate = true;
+
+    await upsertConceptPageEmbedding({
+      slug: "no-summary",
+      dense: [0.1],
+      sparse: { indices: [1], values: [1] },
+      // summary intentionally omitted
+      updatedAt: 1,
+    });
+
+    const [point] = state.upsertCalls[0].points;
+    const vectorRecord = point.vector as unknown as Record<string, unknown>;
+    expect(vectorRecord.summary_dense).toBeUndefined();
+    expect(vectorRecord.summary_sparse).toBeUndefined();
+  });
+
   test("two upserts for the same slug share the same point id (overwrites in place)", async () => {
     state.collectionExistsBeforeCreate = true;
 
@@ -357,8 +607,9 @@ describe("memory v2 qdrant — hybrid query", () => {
   beforeEach(resetState);
   afterEach(resetState);
 
-  test("runs both dense and sparse queries and returns per-channel scores", async () => {
+  test("runs all four channels (body dense/sparse + summary dense/sparse) and returns per-channel scores", async () => {
     state.collectionExistsBeforeCreate = true;
+    // Body channel hits.
     state.queryResponses.dense.push({
       points: [
         { score: 0.91, payload: { slug: "alice-prefers-vs-code" } },
@@ -371,6 +622,14 @@ describe("memory v2 qdrant — hybrid query", () => {
         { score: 3, payload: { slug: "bob-uses-zsh" } },
       ],
     });
+    // Summary channel hits — queue order is body-dense, body-sparse,
+    // summary-dense, summary-sparse, so push summaries after bodies.
+    state.queryResponses.dense.push({
+      points: [{ score: 0.81, payload: { slug: "alice-prefers-vs-code" } }],
+    });
+    state.queryResponses.sparse.push({
+      points: [{ score: 9, payload: { slug: "alice-prefers-vs-code" } }],
+    });
 
     const results = await hybridQueryConceptPages(
       [0.1, 0.2, 0.3],
@@ -378,14 +637,19 @@ describe("memory v2 qdrant — hybrid query", () => {
       5,
     );
 
-    // Both queries fired, with the same limit and the right `using`.
-    expect(state.queryCalls).toHaveLength(2);
+    // All four queries fired with the same limit and distinct `using`.
+    expect(state.queryCalls).toHaveLength(4);
     const usings = state.queryCalls.map((c) => c.using).sort();
-    expect(usings).toEqual(["dense", "sparse"]);
+    expect(usings).toEqual([
+      "dense",
+      "sparse",
+      "summary_dense",
+      "summary_sparse",
+    ]);
     expect(state.queryCalls.every((c) => c.limit === 5)).toBe(true);
     expect(state.queryCalls.every((c) => c.with_payload === true)).toBe(true);
 
-    // Each slug exposes both channel scores.
+    // Alice has hits on all four channels; bob is body-only.
     expect(results).toHaveLength(2);
     const alice = results.find((r) => r.slug === "alice-prefers-vs-code");
     const bob = results.find((r) => r.slug === "bob-uses-zsh");
@@ -393,6 +657,8 @@ describe("memory v2 qdrant — hybrid query", () => {
       slug: "alice-prefers-vs-code",
       denseScore: 0.91,
       sparseScore: 12,
+      summaryDenseScore: 0.81,
+      summarySparseScore: 9,
     });
     expect(bob).toEqual({
       slug: "bob-uses-zsh",
@@ -403,6 +669,8 @@ describe("memory v2 qdrant — hybrid query", () => {
 
   test("dense-only hits leave sparseScore undefined (and vice versa)", async () => {
     state.collectionExistsBeforeCreate = true;
+    // Body dense + sparse hits. Summary channels stay empty (no push) →
+    // they fall through to `{ points: [] }` and produce no summary scores.
     state.queryResponses.dense.push({
       points: [{ score: 0.7, payload: { slug: "dense-only" } }],
     });
@@ -420,8 +688,41 @@ describe("memory v2 qdrant — hybrid query", () => {
     const sparseOnly = results.find((r) => r.slug === "sparse-only");
     expect(denseOnly).toEqual({ slug: "dense-only", denseScore: 0.7 });
     expect(denseOnly?.sparseScore).toBeUndefined();
+    expect(denseOnly?.summaryDenseScore).toBeUndefined();
     expect(sparseOnly).toEqual({ slug: "sparse-only", sparseScore: 2 });
     expect(sparseOnly?.denseScore).toBeUndefined();
+    expect(sparseOnly?.summarySparseScore).toBeUndefined();
+  });
+
+  test("returns summary-channel scores when only the summary side hits", async () => {
+    // Page has no body hits but matches via the summary embedding —
+    // exercises the path where `simBatch` falls back to summary-only.
+    state.collectionExistsBeforeCreate = true;
+    // Body channels empty.
+    state.queryResponses.dense.push({ points: [] });
+    state.queryResponses.sparse.push({ points: [] });
+    // Summary channels hit.
+    state.queryResponses.dense.push({
+      points: [{ score: 0.6, payload: { slug: "summary-only" } }],
+    });
+    state.queryResponses.sparse.push({
+      points: [{ score: 4, payload: { slug: "summary-only" } }],
+    });
+
+    const results = await hybridQueryConceptPages(
+      [0.1],
+      { indices: [1], values: [1] },
+      5,
+    );
+
+    const summaryOnly = results.find((r) => r.slug === "summary-only");
+    expect(summaryOnly).toEqual({
+      slug: "summary-only",
+      summaryDenseScore: 0.6,
+      summarySparseScore: 4,
+    });
+    expect(summaryOnly?.denseScore).toBeUndefined();
+    expect(summaryOnly?.sparseScore).toBeUndefined();
   });
 
   test("does not use Qdrant-side RRF fusion (separate per-channel queries)", async () => {

package/src/memory/v2/__tests__/sim.test.ts

@@ -136,7 +136,11 @@ class MockQdrantClient {
       limit: params.limit,
       filter: params.filter,
     });
-    const channel = params.using as "dense" | "sparse";
+    // Both `dense` and `summary_dense` consume from the dense queue (and
+    // similarly for sparse). The four-channel hybrid query fires them in
+    // order: body-dense, body-sparse, summary-dense, summary-sparse — so
+    // the queue order matches the call order.
+    const channel = params.using.endsWith("sparse") ? "sparse" : "dense";
     return state.queryResponses[channel].shift() ?? { points: [] };
   }
 }
@@ -185,10 +189,18 @@ function configWithWeights(
 /**
  * Stage a single Qdrant response that maps each (slug, denseScore?, sparseScore?)
  * tuple onto the dense or sparse channel, mirroring how `hybridQueryConceptPages`
- * merges per-channel hits.
+ * merges per-channel hits. Optional `summaryDenseScore` / `summarySparseScore`
+ * stage the summary-side channels — pages without those entries fall through
+ * to body-only scoring at fusion time.
  */
 function stageHybridResponse(
-  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+  hits: Array<{
+    slug: string;
+    denseScore?: number;
+    sparseScore?: number;
+    summaryDenseScore?: number;
+    summarySparseScore?: number;
+  }>,
 ): void {
   state.queryResponses.dense.push({
     points: hits
@@ -200,6 +212,20 @@ function stageHybridResponse(
       .filter((h) => h.sparseScore !== undefined)
       .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
   });
+  // The four-channel hybrid query also fires `summary_dense` and
+  // `summary_sparse` queries against the same collection. Tests that don't
+  // care about summary scores leave those channels empty so the fallback
+  // (body-only) path runs.
+  state.queryResponses.dense.push({
+    points: hits
+      .filter((h) => h.summaryDenseScore !== undefined)
+      .map((h) => ({ score: h.summaryDenseScore, payload: { slug: h.slug } })),
+  });
+  state.queryResponses.sparse.push({
+    points: hits
+      .filter((h) => h.summarySparseScore !== undefined)
+      .map((h) => ({ score: h.summarySparseScore, payload: { slug: h.slug } })),
+  });
 }
 
 beforeEach(resetState);
@@ -468,15 +494,16 @@ describe("simBatch", () => {
     expect(out.get("loud-page")).toBe(1);
   });
 
-  test("forwards the candidate slugs as a Qdrant slug-IN filter", async () => {
+  test("forwards the candidate slugs as a Qdrant slug-IN filter on every channel", async () => {
     const config = configWithWeights(0.7, 0.3);
     stageHybridResponse([]);
 
     await simBatch("query", ["alice", "bob", "carol"], config);
 
-    // Both channels (dense + sparse) ran with the same slug-restriction
-    // filter and the same per-channel limit equal to the candidate count.
-    expect(state.queryCalls).toHaveLength(2);
+    // All four channels (body dense + sparse, summary dense + sparse) ran
+    // with the same slug-restriction filter and the same per-channel limit
+    // equal to the candidate count.
+    expect(state.queryCalls).toHaveLength(4);
     for (const call of state.queryCalls) {
       expect(call.limit).toBe(3);
       expect(call.filter).toEqual({
@@ -496,6 +523,90 @@ describe("simBatch", () => {
     expect(state.sparseCalls).toEqual(["hello world"]);
   });
 
+  test("takes max(body, summary) per slug — summary higher than body wins", async () => {
+    // Body channels return a modest score; summary channels return a much
+    // higher score. The max collapses to the summary score.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.3,
+        summaryDenseScore: 0.7,
+      },
+    ]);
+
+    const out = await simBatch("query", ["alice"], config);
+
+    expect(out.get("alice")).toBeCloseTo(0.7, 6);
+  });
+
+  test("takes max(body, summary) per slug — body higher than summary wins", async () => {
+    // Inverse case: body dominates, max stays at body.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.9,
+        summaryDenseScore: 0.4,
+      },
+    ]);
+
+    const out = await simBatch("query", ["alice"], config);
+
+    expect(out.get("alice")).toBeCloseTo(0.9, 6);
+  });
+
+  test("falls back to body-only when the page has no summary embedding", async () => {
+    // Pages predating the summary field have no summary_dense/sparse vectors.
+    // Their summary channels return no hits — the max collapses to body.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "legacy-page",
+        denseScore: 0.6,
+        // summaryDenseScore / summarySparseScore omitted
+      },
+    ]);
+
+    const out = await simBatch("query", ["legacy-page"], config);
+
+    expect(out.get("legacy-page")).toBeCloseTo(0.6, 6);
+  });
+
+  test("normalizes body and summary sparse channels independently", async () => {
+    // Summary sparse scores live on a different scale than body sparse —
+    // a small absolute summary-sparse value (1.5) on the only page that
+    // has summary signal still normalizes to 1.0 within the summary
+    // channel, so the summary-only fused score should win out.
+    const config = configWithWeights(0.0, 1.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.0,
+        sparseScore: 100, // body sparse max in this batch
+      },
+      {
+        slug: "bob",
+        denseScore: 0.0,
+        sparseScore: 0.5, // body sparse normalized = 0.005
+        summaryDenseScore: 0.0,
+        summarySparseScore: 1.5, // summary sparse max in this batch
+      },
+    ]);
+
+    const out = await simBatch("query", ["alice", "bob"], config);
+
+    // Alice has only body. Body sparse normalized to 1.0; sparse_weight=1.0 → 1.0.
+    expect(out.get("alice")).toBeCloseTo(1.0, 6);
+    // Bob's summary side normalizes its 1.5 (only sparse-bearing summary
+    // hit) — a single sparse-bearing hit is below the adaptive-spread
+    // floor, so the channel collapses to base weights and the lone
+    // sparseNormalized=1.0 hit yields a fused summary score of 1.0.
+    // Body side has only bob's tiny sparse=0.5 against the body batch max
+    // of 100 → ~0.005. The max picks the summary side.
+    expect(out.get("bob")).toBeCloseTo(1.0, 6);
+  });
+
   test("returned scores are always in [0, 1] for arbitrary inputs", async () => {
     const config = configWithWeights(0.7, 0.3);
     stageHybridResponse([

package/src/memory/v2/__tests__/static-context.test.ts

@@ -1,8 +1,6 @@
 /**
  * Tests for `readMemoryV2StaticContent` — the loader that powers the
- * `memory-v2-static` user-message auto-injection. Mirrors the coverage that
- * lived in the deprecated `system-prompt-memory-v2.test.ts`:
- *   - Returns null when the v2 flag is off.
+ * `memory-v2-static` user-message auto-injection.
  *   - Returns null when `config.memory.v2.enabled` is off.
  *   - Reads the four files in canonical order and joins them under headings.
  *   - Skips empty / missing files.
@@ -47,8 +45,6 @@ mock.module("../../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
 const { readMemoryV2StaticContent, shouldLoadMemoryV2Static } =
   await import("../static-context.js");
 
@@ -75,18 +71,10 @@ describe("readMemoryV2StaticContent", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
     configMemoryV2Enabled = true;
-    _setOverridesForTesting({ "memory-v2-enabled": true });
   });
 
   afterEach(() => {
     cleanupMemoryDir();
-    _setOverridesForTesting({});
-  });
-
-  test("returns null when the feature flag is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
-    expect(readMemoryV2StaticContent()).toBeNull();
   });
 
   test("returns null when config.memory.v2.enabled is off", () => {