@vellumai/assistant 0.7.3 → 0.8.0

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -86,6 +86,10 @@ const upsertCalls: Array<{
   slug: string;
   dense: number[];
   sparse: { indices: number[]; values: number[] };
+  summary?: {
+    dense: number[];
+    sparse: { indices: number[]; values: number[] };
+  };
   updatedAt: number;
 }> = [];
 
@@ -96,6 +100,10 @@ mock.module("../../v2/qdrant.js", () => ({
     slug: string;
     dense: number[];
     sparse: { indices: number[]; values: number[] };
+    summary?: {
+      dense: number[];
+      sparse: { indices: number[]; values: number[] };
+    };
     updatedAt: number;
   }) => {
     upsertCalls.push(params);
@@ -242,6 +250,114 @@ describe("embedConceptPageJob — happy path", () => {
   });
 });
 
+describe("embedConceptPageJob — summary embedding", () => {
+  test("embeds the summary when present and forwards summary vectors to upsert", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "summarized-page",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "A short prose summary that retrieval indexes separately.",
+      },
+      body: "Long-form body content.\n",
+    });
+
+    await embedConceptPageJob(
+      makeJob({ slug: "summarized-page" }),
+      TEST_CONFIG,
+    );
+
+    // Body and summary are batched into one backend call (saves a round-trip).
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0];
+    expect(call.slug).toBe("summarized-page");
+    expect(call.dense).toEqual([0.1, 0.2, 0.3, 0.4]);
+    expect(call.sparse).toBeDefined();
+    expect(call.summary?.dense).toEqual([0.1, 0.2, 0.3, 0.4]);
+    expect(call.summary?.sparse).toBeDefined();
+  });
+
+  test("skips summary embedding when the page has no summary in frontmatter", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "legacy-page",
+      frontmatter: { edges: [], ref_files: [] },
+      body: "Body only — no summary in frontmatter.\n",
+    });
+
+    await embedConceptPageJob(makeJob({ slug: "legacy-page" }), TEST_CONFIG);
+
+    // Only the body was embedded.
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0];
+    expect(call.summary).toBeUndefined();
+  });
+
+  test("skips summary embedding when the summary is whitespace-only", async () => {
+    // Whitespace-only summaries (` `, `\n`) are equivalent to absent — the
+    // embedding backend would reject the empty input downstream anyway.
+    await writePage(tmpWorkspace, {
+      slug: "whitespace-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "   ",
+      },
+      body: "Body content.\n",
+    });
+
+    await embedConceptPageJob(
+      makeJob({ slug: "whitespace-summary" }),
+      TEST_CONFIG,
+    );
+
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(upsertCalls[0].summary).toBeUndefined();
+  });
+
+  test("body and summary cache rows are independent (summary edit doesn't invalidate body)", async () => {
+    // Write a page with a summary, run the job to prime caches.
+    await writePage(tmpWorkspace, {
+      slug: "cached-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "First version of the summary.",
+      },
+      body: "Stable body that never changes.\n",
+    });
+    await embedConceptPageJob(
+      makeJob({ slug: "cached-summary" }),
+      TEST_CONFIG,
+    );
+    // Body + summary batched into a single backend call on first run.
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
+
+    // Edit only the summary — body stays identical, only the summary text
+    // changes. Re-running the job should hit the body cache (no re-embed)
+    // but recompute the summary embedding.
+    await writePage(tmpWorkspace, {
+      slug: "cached-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "Second version of the summary, different wording.",
+      },
+      body: "Stable body that never changes.\n",
+    });
+    await embedConceptPageJob(
+      makeJob({ slug: "cached-summary" }),
+      TEST_CONFIG,
+    );
+    // One additional backend call with only the summary text — body hit the cache.
+    expect(embedWithBackendCalls).toHaveLength(2);
+    expect(embedWithBackendCalls[1].inputs).toHaveLength(1);
+  });
+});
+
 describe("embedConceptPageJob — cache hit", () => {
   test("reuses the cached dense vector when content hash matches", async () => {
     await writePage(tmpWorkspace, {

package/src/memory/jobs/embed-concept-page.ts

@@ -98,52 +98,93 @@ export async function embedConceptPageJob(
     );
   }
 
-  const contentHash = embeddingInputContentHash({ type: "text", text });
   const expectedDim = config.memory.qdrant.vectorSize;
-  let provider = status.provider;
-  let model = status.model!;
+  // The status provider is the cache lookup key for any prior row; the
+  // *actual* provider/model come back on the embedded result. They usually
+  // match, but a backend swap mid-run would surface here — body and summary
+  // are then re-embedded together so both rows write under the same identity.
+  const cacheProvider = status.provider;
+  const cacheModel = status.model!;
+
+  const db = getDb();
 
   // Cache lookup: same (targetType, targetId, provider, model) row gets
   // reused across runs as long as `contentHash` matches. The dim mismatch
   // check guards against a config change (vectorSize bumped) since the last
-  // write — in that case we treat the row as stale and re-embed.
-  const db = getDb();
-  let cachedRow = db
-    .select({
-      vectorBlob: memoryEmbeddings.vectorBlob,
-      vectorJson: memoryEmbeddings.vectorJson,
-      dimensions: memoryEmbeddings.dimensions,
-      contentHash: memoryEmbeddings.contentHash,
-    })
-    .from(memoryEmbeddings)
-    .where(
-      and(
-        eq(memoryEmbeddings.targetType, CONCEPT_PAGE_TARGET_TYPE),
-        eq(memoryEmbeddings.targetId, slug),
-        eq(memoryEmbeddings.provider, provider),
-        eq(memoryEmbeddings.model, model),
-      ),
-    )
-    .get();
-  if (cachedRow && cachedRow.dimensions !== expectedDim) cachedRow = undefined;
-  if (cachedRow && cachedRow.contentHash !== contentHash) cachedRow = undefined;
-
-  let dense: number[];
-  let cacheHit = false;
-  if (cachedRow) {
-    dense = cachedRow.vectorBlob
-      ? blobToVector(cachedRow.vectorBlob as Buffer)
-      : (JSON.parse(cachedRow.vectorJson!) as number[]);
-    cacheHit = true;
-  } else {
-    const embedded = await embedWithBackend(config, [{ type: "text", text }]);
-    const vector = embedded.vectors[0];
-    if (!vector) return;
-    dense = vector;
-    provider = embedded.provider;
-    model = embedded.model;
+  // write — in that case we treat the row as stale and re-embed. The body
+  // and (optional) summary share the same provider/model — but each gets
+  // its own cache row keyed by a distinct targetId so summary edits don't
+  // invalidate the body cache and vice versa.
+  const bodyContentHash = embeddingInputContentHash({ type: "text", text });
+  const bodyCache = readEmbeddingCache(
+    db,
+    slug,
+    cacheProvider,
+    cacheModel,
+    expectedDim,
+  );
+  const bodyCacheHit = bodyCache?.contentHash === bodyContentHash;
+
+  // Optional summary embedding — only when the page has a `summary` in its
+  // frontmatter. Pages without one fall back to body-only retrieval at
+  // query time (the activation pipeline reads the summary score as
+  // undefined and uses the body score directly).
+  const summaryText = page.frontmatter.summary?.trim() ?? "";
+  const hasSummary = summaryText.length > 0;
+  const summaryCacheId = `${slug}#summary`;
+  const summaryContentHash = hasSummary
+    ? embeddingInputContentHash({ type: "text", text: summaryText })
+    : undefined;
+  const summaryCache = hasSummary
+    ? readEmbeddingCache(
+        db,
+        summaryCacheId,
+        cacheProvider,
+        cacheModel,
+        expectedDim,
+      )
+    : null;
+  const summaryCacheHit =
+    hasSummary && summaryCache?.contentHash === summaryContentHash;
+
+  // Batch all cache misses into one `embedWithBackend` call. Each backend
+  // round-trip is the dominant cost — fresh body + fresh summary in a
+  // single batch saves a round-trip vs serial calls and gives both vectors
+  // the same provider/model regardless of any backend rotation mid-run.
+  type Slot = "body" | "summary";
+  const toEmbed: Array<{ type: "text"; text: string }> = [];
+  const slots: Slot[] = [];
+  if (!bodyCacheHit) {
+    toEmbed.push({ type: "text", text });
+    slots.push("body");
+  }
+  if (hasSummary && !summaryCacheHit) {
+    toEmbed.push({ type: "text", text: summaryText });
+    slots.push("summary");
   }
 
+  let bodyDense: number[] | undefined = bodyCacheHit ? bodyCache!.dense : undefined;
+  let summaryDense: number[] | undefined = summaryCacheHit
+    ? summaryCache!.dense
+    : undefined;
+  let writeProvider = cacheProvider;
+  let writeModel = cacheModel;
+  if (toEmbed.length > 0) {
+    const embedded = await embedWithBackend(config, toEmbed);
+    writeProvider = embedded.provider;
+    writeModel = embedded.model;
+    for (let i = 0; i < slots.length; i++) {
+      const vector = embedded.vectors[i];
+      if (!vector) continue;
+      if (slots[i] === "body") bodyDense = vector;
+      else summaryDense = vector;
+    }
+  }
+  // Body embedding is the ground truth — without it the page can't surface.
+  // (Cache hit paths populate `bodyDense` above; a fresh embed that returned
+  // no vectors short-circuits here too.)
+  if (!bodyDense) return;
+
   // Sparse is cheap (in-process tokenization) and changes any time the body
   // changes, so we always recompute it rather than caching alongside dense.
   // BM25 weights live on the doc side; queries embed binary occurrence in
@@ -151,57 +192,42 @@ export async function embedConceptPageJob(
   // corpus for the first time), fall back to the legacy TF-only encoding —
   // the next reembed pass overwrites the page once stats are available.
   const corpusStats = getConceptPageCorpusStats();
-  const sparse = corpusStats
-    ? generateBm25DocEmbedding(text, corpusStats, {
-        k1: config.memory.v2.bm25_k1,
-        b: config.memory.v2.bm25_b,
-      })
-    : generateSparseEmbedding(text);
+  const encodeSparse = (input: string) =>
+    corpusStats
+      ? generateBm25DocEmbedding(input, corpusStats, {
+          k1: config.memory.v2.bm25_k1,
+          b: config.memory.v2.bm25_b,
+        })
+      : generateSparseEmbedding(input);
+  const sparse = encodeSparse(text);
+  const summarySparse = hasSummary ? encodeSparse(summaryText) : undefined;
 
   const now = Date.now();
   // Persist freshly embedded vectors for cross-restart reuse. On cache hit
   // the existing row already has identical content + hash, so the write
   // would be a no-op — skip it. Best-effort: write failure is not fatal,
   // we still want the Qdrant upsert below to fire.
-  if (!cacheHit) {
-    try {
-      const blobValue = vectorToBlob(dense);
-      db.insert(memoryEmbeddings)
-        .values({
-          id: randomUUID(),
-          targetType: CONCEPT_PAGE_TARGET_TYPE,
-          targetId: slug,
-          provider,
-          model,
-          dimensions: dense.length,
-          vectorBlob: blobValue,
-          vectorJson: null,
-          contentHash,
-          createdAt: now,
-          updatedAt: now,
-        })
-        .onConflictDoUpdate({
-          target: [
-            memoryEmbeddings.targetType,
-            memoryEmbeddings.targetId,
-            memoryEmbeddings.provider,
-            memoryEmbeddings.model,
-          ],
-          set: {
-            vectorBlob: blobValue,
-            vectorJson: null,
-            dimensions: dense.length,
-            contentHash,
-            updatedAt: now,
-          },
-        })
-        .run();
-    } catch (err) {
-      log.warn(
-        { err, slug },
-        "Failed to write concept-page embedding cache row",
-      );
-    }
+  if (!bodyCacheHit) {
+    writeEmbeddingCache(db, {
+      slug,
+      cacheId: slug,
+      dense: bodyDense,
+      contentHash: bodyContentHash,
+      provider: writeProvider,
+      model: writeModel,
+      now,
+    });
+  }
+  if (hasSummary && !summaryCacheHit && summaryDense && summaryContentHash) {
+    writeEmbeddingCache(db, {
+      slug,
+      cacheId: summaryCacheId,
+      dense: summaryDense,
+      contentHash: summaryContentHash,
+      provider: writeProvider,
+      model: writeModel,
+      now,
+    });
   }
 
   // Apply anisotropy correction at the boundary between the (raw) cached
@@ -210,19 +236,129 @@ export async function embedConceptPageJob(
   // the cache survives and the (cheap) correction math reruns over each
   // cached vector. Pass-through when no calibration is fit yet.
   const correctedDense = await applyCorrectionIfCalibrated(
-    dense,
-    provider,
-    model,
+    bodyDense,
+    writeProvider,
+    writeModel,
   );
+  const correctedSummaryDense = summaryDense
+    ? await applyCorrectionIfCalibrated(summaryDense, writeProvider, writeModel)
+    : undefined;
 
   await upsertConceptPageEmbedding({
     slug,
     dense: correctedDense,
     sparse,
+    summary:
+      correctedSummaryDense && summarySparse
+        ? { dense: correctedSummaryDense, sparse: summarySparse }
+        : undefined,
     updatedAt: now,
   });
 }
 
+/** SQLite cache row shape returned by `readEmbeddingCache`. */
+interface EmbeddingCacheEntry {
+  dense: number[];
+  contentHash: string;
+}
+
+/**
+ * Look up a cached dense vector keyed on `(targetType, targetId, provider,
+ * model)`. Returns the row only when the persisted dimensions match the
+ * configured expectation — a stale row from a previous `vectorSize` is
+ * treated as a cache miss so the caller re-embeds.
+ */
+function readEmbeddingCache(
+  db: ReturnType<typeof getDb>,
+  cacheId: string,
+  provider: string,
+  model: string,
+  expectedDim: number,
+): EmbeddingCacheEntry | null {
+  const row = db
+    .select({
+      vectorBlob: memoryEmbeddings.vectorBlob,
+      vectorJson: memoryEmbeddings.vectorJson,
+      dimensions: memoryEmbeddings.dimensions,
+      contentHash: memoryEmbeddings.contentHash,
+    })
+    .from(memoryEmbeddings)
+    .where(
+      and(
+        eq(memoryEmbeddings.targetType, CONCEPT_PAGE_TARGET_TYPE),
+        eq(memoryEmbeddings.targetId, cacheId),
+        eq(memoryEmbeddings.provider, provider),
+        eq(memoryEmbeddings.model, model),
+      ),
+    )
+    .get();
+  if (!row || row.dimensions !== expectedDim) return null;
+  // A row without a contentHash is a legacy/corrupt entry — treat as a miss
+  // and force a re-embed rather than misalign the cache key.
+  if (row.contentHash === null) return null;
+  const dense = row.vectorBlob
+    ? blobToVector(row.vectorBlob as Buffer)
+    : (JSON.parse(row.vectorJson!) as number[]);
+  return { dense, contentHash: row.contentHash };
+}
+
+/**
+ * Persist a freshly embedded dense vector in the SQLite cache. Best-effort:
+ * a write failure is logged and swallowed so the Qdrant upsert still runs.
+ */
+function writeEmbeddingCache(
+  db: ReturnType<typeof getDb>,
+  params: {
+    slug: string;
+    cacheId: string;
+    dense: number[];
+    contentHash: string;
+    provider: string;
+    model: string;
+    now: number;
+  },
+): void {
+  const { slug, cacheId, dense, contentHash, provider, model, now } = params;
+  try {
+    const blobValue = vectorToBlob(dense);
+    db.insert(memoryEmbeddings)
+      .values({
+        id: randomUUID(),
+        targetType: CONCEPT_PAGE_TARGET_TYPE,
+        targetId: cacheId,
+        provider,
+        model,
+        dimensions: dense.length,
+        vectorBlob: blobValue,
+        vectorJson: null,
+        contentHash,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: [
+          memoryEmbeddings.targetType,
+          memoryEmbeddings.targetId,
+          memoryEmbeddings.provider,
+          memoryEmbeddings.model,
+        ],
+        set: {
+          vectorBlob: blobValue,
+          vectorJson: null,
+          dimensions: dense.length,
+          contentHash,
+          updatedAt: now,
+        },
+      })
+      .run();
+  } catch (err) {
+    log.warn(
+      { err, slug, cacheId },
+      "Failed to write concept-page embedding cache row",
+    );
+  }
+}
+
 /**
  * Enqueue an `embed_concept_page` job (async, fire-and-forget). Modeled on
  * `enqueuePkbIndexJob` — callers that want a slug re-embedded after a write

package/src/memory/jobs-worker.ts

@@ -11,7 +11,6 @@ import {
   getLastScheduledCleanupEnqueueMs,
   markScheduledCleanupEnqueued,
 } from "./cleanup-schedule-state.js";
-import { isMemoryV2ReadActive } from "./context-search/sources/memory-v2.js";
 import { conversationAnalyzeJob } from "./conversation-analyze-job.js";
 import { maybeRunDbMaintenance } from "./db-maintenance.js";
 import { bootstrapFromHistory } from "./graph/bootstrap.js";
@@ -510,6 +509,11 @@ async function processJob(
       await embedGraphTriggerJob(job, config);
       return;
     case "graph_extract":
+      // Stale rows enqueued before v2 was enabled (or by any unguarded v1
+      // path) must not consume embedding/extraction budget when v2 is on.
+      if (config.memory.v2.enabled) {
+        return;
+      }
       await graphExtractJob(job, config);
       return;
     case "conversation_analyze":
@@ -623,8 +627,8 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
  * Enqueue periodic graph maintenance jobs.
  *
  * Mutually exclusive between v1 and v2:
- *   - v2 active (both `memory-v2-enabled` flag and `memory.v2.enabled`
- *     config on) → only `memory_v2_consolidate` is scheduled.
+ *   - v2 active (`memory.v2.enabled` on) → only `memory_v2_consolidate` is
+ *     scheduled.
  *   - v2 inactive → the four v1 entries (decay, consolidate, pattern_scan,
  *     narrative) are scheduled instead.
  *
@@ -643,7 +647,7 @@ export function maybeEnqueueGraphMaintenanceJobs(
   config: AssistantConfig,
   nowMs = Date.now(),
 ): void {
-  const v2Active = isMemoryV2ReadActive(config);
+  const v2Active = config.memory.v2.enabled;
 
   const schedule: Array<{
     key: string;

package/src/memory/pkb/pkb-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 PKB search path. The `memory-v2-enabled` flag
-// (registry default `true`) makes pkb-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 PKB search path. `config.memory.v2.enabled`
+// (default `true`) makes pkb-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/pkb/pkb-search.ts

@@ -4,7 +4,6 @@
 
 import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import {
   isQdrantBreakerOpen,
   withQdrantBreaker,
@@ -42,10 +41,10 @@ export async function searchPkbFiles(
   limit: number,
   scopeIds?: string[],
 ): Promise<PkbSearchResult[]> {
-  // v2 owns the read path when both gates are on; v2 absorbs PKB as a read
-  // source, so PKB hint search short-circuits to keep traffic off the v1
-  // collection (avoiding OOM-crash risk from a corrupted sparse segment).
-  if (isMemoryV2ReadActive(getConfig())) return [];
+  // v2 owns the read path when enabled; v2 absorbs PKB as a read source,
+  // so PKB hint search short-circuits to keep traffic off the v1 collection
+  // (avoiding OOM-crash risk from a corrupted sparse segment).
+  if (getConfig().memory.v2.enabled) return [];
 
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping PKB search");

package/src/memory/qdrant-client.ts

@@ -248,6 +248,9 @@ export class VellumQdrantClient {
           m: 16,
           ef_construct: 100,
         },
+        optimizers_config: {
+          default_segment_number: 2,
+        },
         quantization_config:
           this.quantization === "scalar"
             ? {

package/src/memory/search/semantic.ts

@@ -1,7 +1,6 @@
 import { inArray } from "drizzle-orm";
 
 import { getConfig } from "../../config/loader.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { getDb } from "../db-connection.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import type {
@@ -56,10 +55,10 @@ export async function semanticSearch(
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
-  // v2 owns the read path when both gates are on; the v1 `memory` collection
-  // is in active retirement, and routing semantic recall there would re-enter
-  // the same corrupted sparse segments that can OOM-crash Qdrant.
-  if (isMemoryV2ReadActive(getConfig())) return [];
+  // v2 owns the read path when enabled; the v1 `memory` collection is in
+  // active retirement, and routing semantic recall there would re-enter the
+  // same corrupted sparse segments that can OOM-crash Qdrant.
+  if (getConfig().memory.v2.enabled) return [];
 
   const qdrant = getQdrantClient();
 

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

@@ -114,7 +114,10 @@ class MockQdrantClient {
       limit: params.limit,
       filter: params.filter,
     });
-    const channel = params.using as "dense" | "sparse";
+    // 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 state.queryResponses[channel].shift() ?? { points: [] };
   }
 }
@@ -223,9 +226,20 @@ function makeConfig(
   } as unknown as AssistantConfig;
 }
 
-/** Stage a single dense + sparse pair on the response queues. */
+/**
+ * Stage a single hybrid-query response — body channels first, then summary
+ * channels (which default to empty). The four-channel hybrid query fires
+ * body-dense, body-sparse, summary-dense, summary-sparse in that order, so
+ * each logical call consumes 2 dense + 2 sparse queue entries.
+ */
 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
@@ -237,6 +251,22 @@ function stageHybridResponse(
       .filter((h) => h.sparseScore !== undefined)
       .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
   });
+  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);
@@ -369,7 +399,7 @@ describe("selectCandidates", () => {
       nowText: "",
       config: makeConfig(),
     });
-    expect(state.queryCalls).toHaveLength(2);
+    expect(state.queryCalls).toHaveLength(4);
     for (const call of state.queryCalls) {
       expect(call.limit).toBe(1_000_000);
       expect(call.filter).toBeUndefined();
@@ -385,7 +415,7 @@ describe("selectCandidates", () => {
       nowText: "",
       config: makeConfig({ ann_candidate_limit: 25 }),
     });
-    expect(state.queryCalls).toHaveLength(2);
+    expect(state.queryCalls).toHaveLength(4);
     for (const call of state.queryCalls) {
       expect(call.limit).toBe(25);
       expect(call.filter).toBeUndefined();