@vellumai/assistant 0.7.2 → 0.7.3

package/src/memory/v2/injection.ts

@@ -29,21 +29,18 @@ import { getWorkspaceDir } from "../../util/platform.js";
 import type { DrizzleDb } from "../db-connection.js";
 import {
   type MemoryV2ConceptRowRecord,
-  type MemoryV2SkillRowRecord,
   recordMemoryV2ActivationLog,
 } from "../memory-v2-activation-log-store.js";
 import {
   computeOwnActivation,
-  computeSkillActivation,
   selectCandidates,
   selectInjections,
-  selectSkillInjections,
   spreadActivation,
 } from "./activation.js";
 import { hydrate, save } from "./activation-store.js";
 import { getEdgeIndex } from "./edge-index.js";
 import { readPage, renderPageContent } from "./page-store.js";
-import { getAllSkillIds, getSkillCapability } from "./skill-store.js";
+import { getSkillCapability, isSkillSlug } from "./skill-store.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
 const log = getLogger("memory-v2-injection");
@@ -84,6 +81,7 @@ export interface InjectMemoryV2BlockParams {
    */
   mode?: InjectMemoryV2Mode;
   config: AssistantConfig;
+  signal?: AbortSignal;
 }
 
 export interface InjectMemoryV2BlockResult {
@@ -127,30 +125,36 @@ export async function injectMemoryV2Block(
     nowText,
     messageId,
     config,
+    signal,
   } = params;
 
   const workspaceDir = getWorkspaceDir();
 
   // (1) Hydrate. Missing rows are normal at conversation start — proceed
   // with an effective empty prior state so the first turn can still inject.
+  throwIfAborted(signal);
   const priorState = await hydrate(database, conversationId);
 
   // (2) Topology. `getEdgeIndex` walks concept-page frontmatter and caches
   // the result module-locally; an empty workspace yields an empty index.
+  throwIfAborted(signal);
   const edgeIndex = await getEdgeIndex(workspaceDir);
 
   // (3) Candidate set: prior-state survivors above epsilon ∪ ANN top-50.
   // `selectCandidates` also returns `fromPrior` / `fromAnn` provenance sets so
   // telemetry can attribute each candidate back to its source.
+  throwIfAborted(signal);
   const { candidates, fromPrior, fromAnn } = await selectCandidates({
     priorState,
     userText: userMessage,
     assistantText: assistantMessage,
     nowText,
     config,
+    signal,
   });
 
   // (4) Own activation: A_o = d·prev + c_user·sim_u + c_a·sim_a + c_now·sim_n.
+  throwIfAborted(signal);
   const { activation: ownActivation, breakdown: ownBreakdown } =
     await computeOwnActivation({
       candidates,
@@ -159,9 +163,11 @@ export async function injectMemoryV2Block(
       assistantText: assistantMessage,
       nowText,
       config,
+      signal,
     });
 
   // (5) Spreading activation across the edge graph (k, hops from config).
+  throwIfAborted(signal);
   const { k, hops, top_k, epsilon } = config.memory.v2;
   const { final: finalActivation, contribution: spreadContribution } =
     spreadActivation(ownActivation, edgeIndex, k, hops);
@@ -182,25 +188,6 @@ export async function injectMemoryV2Block(
   });
   const slugsToRender = mode === "context-load" ? topNow : toInject;
 
-  // (6b) Skill pipeline — a sibling pipeline to the concept-page one above.
-  // Skills are stateless (no decay, no spread, no `everInjected` dedup) and
-  // the catalog is small, so every known skill is scored every turn. The
-  // top-K injection slate is re-presented every turn so the agent can drop
-  // and pick skills up freely; the inspector renders the full ranked list.
-  const skillCandidates = new Set(getAllSkillIds());
-  const { activation: skillActivation, breakdown: skillBreakdown } =
-    await computeSkillActivation({
-      candidates: skillCandidates,
-      userText: userMessage,
-      assistantText: assistantMessage,
-      nowText,
-      config,
-    });
-  const { topNow: topSkillIds } = selectSkillInjections({
-    A: skillActivation,
-    topK: config.memory.v2.top_k_skills,
-  });
-
   // Build the next persisted state regardless of whether we render anything:
   // even on a "no new injection" turn, prior-state activations decay via the
   // candidate-set carry-forward and need to be rewritten so `epsilon`-trimmed
@@ -215,8 +202,10 @@ export async function injectMemoryV2Block(
   // just rendered all of them); on per-turn it's just the newly added slugs.
   // We append rather than reset so that compaction-driven eviction
   // (`evictCompactedTurns`) is the only path that can re-enable a previously-
-  // injected slug. Skills do NOT enter `everInjected` — they are stateless
-  // and re-presented every turn.
+  // injected slug. Skill slugs (`skills/<id>`) participate in this dedup just
+  // like concept slugs — once attached on a turn, the cached attachment lives
+  // on that user message and the agent keeps seeing it across subsequent turns
+  // until compaction evicts the turn.
   const everInjectedSet = new Set(priorEverInjected.map((entry) => entry.slug));
   const newlyInjected = slugsToRender.filter(
     (slug) => !everInjectedSet.has(slug),
@@ -243,7 +232,6 @@ export async function injectMemoryV2Block(
   const { block, missingSlugs } = await renderInjectionBlock(
     workspaceDir,
     slugsToRender,
-    topSkillIds,
   );
   const missingSlugSet = new Set(missingSlugs);
   if (missingSlugs.length > 0) {
@@ -262,7 +250,6 @@ export async function injectMemoryV2Block(
   // block memory injection.
   const toInjectSet = new Set(toInject);
   const renderedSet = new Set(slugsToRender);
-  const topSkillIdSet = new Set(topSkillIds);
   const conceptRows: MemoryV2ConceptRowRecord[] = [...candidates].map(
     (slug) => {
       const breakdown = ownBreakdown.get(slug);
@@ -301,6 +288,9 @@ export async function injectMemoryV2Block(
         simUser: breakdown?.simUser ?? 0,
         simAssistant: breakdown?.simAssistant ?? 0,
         simNow: breakdown?.simNow ?? 0,
+        simUserRerankBoost: breakdown?.simUserRerankBoost ?? 0,
+        simAssistantRerankBoost: breakdown?.simAssistantRerankBoost ?? 0,
+        inRerankPool: breakdown?.inRerankPool ?? false,
         spreadContribution: spreadContribution.get(slug) ?? 0,
         source:
           inPrior && inAnn ? "both" : inPrior ? "prior_state" : "ann_top50",
@@ -310,19 +300,6 @@ export async function injectMemoryV2Block(
   );
   conceptRows.sort((a, b) => b.finalActivation - a.finalActivation);
 
-  const skillRows: MemoryV2SkillRowRecord[] = [...skillCandidates].map((id) => {
-    const breakdown = skillBreakdown.get(id);
-    return {
-      id,
-      activation: skillActivation.get(id) ?? 0,
-      simUser: breakdown?.simUser ?? 0,
-      simAssistant: breakdown?.simAssistant ?? 0,
-      simNow: breakdown?.simNow ?? 0,
-      status: topSkillIdSet.has(id) ? "injected" : "not_injected",
-    };
-  });
-  skillRows.sort((a, b) => b.activation - a.activation);
-
   const v2Cfg = config.memory.v2;
   try {
     recordMemoryV2ActivationLog({
@@ -330,7 +307,6 @@ export async function injectMemoryV2Block(
       turn: currentTurn,
       mode,
       concepts: conceptRows,
-      skills: skillRows,
       config: {
         d: v2Cfg.d,
         c_user: v2Cfg.c_user,
@@ -339,7 +315,6 @@ export async function injectMemoryV2Block(
         k: v2Cfg.k,
         hops: v2Cfg.hops,
         top_k: v2Cfg.top_k,
-        top_k_skills: v2Cfg.top_k_skills,
         epsilon: v2Cfg.epsilon,
       },
     });
@@ -353,6 +328,12 @@ export async function injectMemoryV2Block(
   return { block, toInject: newlyInjected };
 }
 
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -380,9 +361,14 @@ interface RenderInjectionBlockResult {
 }
 
 /**
- * Render the inner content of the `<memory>` block for a list of slugs and
- * a list of ranked skill ids. The caller wraps the result in
- * `<memory>...</memory>` exactly once at injection time.
+ * Render the inner content of the `<memory>` block for a list of slugs.
+ * The caller wraps the result in `<memory>...</memory>` exactly once at
+ * injection time.
+ *
+ * The slug list is partitioned by prefix: slugs starting with `skills/`
+ * resolve to a `SkillEntry` via `getSkillCapability` and render under the
+ * trailing `### Skills You Can Use` subsection; everything else is read
+ * from disk via `readPage` and rendered as a concept-page section.
  *
  * Concept pages are read in parallel via `readPage`. Pages whose file has
  * gone missing between selection and render (e.g. consolidation deleted
@@ -390,17 +376,17 @@ interface RenderInjectionBlockResult {
  * block but reported back via `missingSlugs` so callers can surface the
  * divergence.
  *
- * Skill ids are looked up via `getSkillCapability`. Ids that the cache no
- * longer knows (e.g. uninstalled mid-run) are silently dropped, mirroring
- * the missing-pages behavior.
+ * Skill slugs whose entry the cache no longer knows (e.g. uninstalled
+ * mid-run) are silently dropped, mirroring the missing-pages behavior but
+ * without entering `missingSlugs` — the skill catalog is the source of
+ * truth for skill availability, not on-disk concept pages, so a missing
+ * skill is an expected catalog-level outcome rather than a stale-index
+ * bug.
  *
- * The block shape is the §5 layout from the design doc, with an optional
- * trailing skills subsection. Each concept-page section reproduces the page
- * as it lives on disk — frontmatter (`edges`, `ref_files`) plus body — so
- * the agent sees the page's edges and any referenced media paths alongside
- * the prose:
+ * The block shape mirrors the §5 layout — concept-page sections first,
+ * skills subsection last — preserving the prompt format the agent sees:
  *
- *   ### <slug-1>
+ *   ### <concept-slug-1>
  *   ---
  *   edges:
  *     - <neighbor-slug>
@@ -409,7 +395,7 @@ interface RenderInjectionBlockResult {
  *   ---
  *   <body-1>
  *
- *   ### <slug-2>
+ *   ### <concept-slug-2>
  *   ---
  *   edges: []
  *   ref_files: []
@@ -423,10 +409,12 @@ interface RenderInjectionBlockResult {
 async function renderInjectionBlock(
   workspaceDir: string,
   slugs: string[],
-  skillIds: string[],
 ): Promise<RenderInjectionBlockResult> {
+  const conceptSlugs = slugs.filter((s) => !isSkillSlug(s));
+  const skillSlugs = slugs.filter((s) => isSkillSlug(s));
+
   const pages = await Promise.all(
-    slugs.map(async (slug) => {
+    conceptSlugs.map(async (slug) => {
       const page = await readPage(workspaceDir, slug);
       return { slug, page };
     }),
@@ -444,10 +432,9 @@ async function renderInjectionBlock(
     sections.push(`### ${slug}\n${content}`);
   }
 
-  // v2's skills collection is skills-only, so the activation suffix always applies.
   const skillLines: string[] = [];
-  for (const id of skillIds) {
-    const entry = getSkillCapability(id);
+  for (const slug of skillSlugs) {
+    const entry = getSkillCapability(slug);
     if (!entry) continue;
     skillLines.push(`- ${entry.content} → use skill_load to activate`);
   }

package/src/memory/v2/prompts/consolidation.ts

@@ -16,7 +16,7 @@
  * the convention established for the sweep prompt.
  */
 
-import { readFileSync } from "node:fs";
+import { lstatSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 
@@ -28,6 +28,14 @@ const log = getLogger("memory-v2-consolidate-prompt");
 /** Sentinel substituted with the cutoff timestamp at runtime. */
 export const CUTOFF_PLACEHOLDER = "{{CUTOFF}}";
 
+/**
+ * Upper bound for the override file. Real consolidation prompts are kilobytes;
+ * 1 MiB is generous headroom while preventing a `settings.write` principal from
+ * pointing the field at a multi-gigabyte file (or `/dev/zero`-like stream that
+ * `lstat` can't size cap on its own) and exfiltrating it through the wake hint.
+ */
+const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
+
 /**
  * Consolidation prompt — live-mode only. The agent runs as itself (full
  * SOUL.md + IDENTITY.md + persona + memory autoloads) with the standard
@@ -447,6 +455,33 @@ export function resolveConsolidationPrompt(
   const resolvedPath = resolveOverridePath(overridePath);
   let contents: string;
   try {
+    const stat = lstatSync(resolvedPath);
+    if (!stat.isFile()) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          reason: "not_regular_file",
+          fallback: "bundled",
+        },
+        "consolidation prompt override is not a regular file; using bundled prompt",
+      );
+      return renderConsolidationPrompt(cutoff);
+    }
+    if (stat.size > MAX_PROMPT_BYTES) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          size: stat.size,
+          limit: MAX_PROMPT_BYTES,
+          reason: "oversized_override",
+          fallback: "bundled",
+        },
+        "consolidation prompt override exceeds size limit; using bundled prompt",
+      );
+      return renderConsolidationPrompt(cutoff);
+    }
     contents = readFileSync(resolvedPath, "utf-8");
   } catch (err) {
     const code = (err as NodeJS.ErrnoException).code;

package/src/memory/v2/qdrant.ts

@@ -62,6 +62,7 @@ export interface ConceptPageQueryResult {
 
 let _client: QdrantRestClient | null = null;
 let _collectionReady = false;
+let _collectionReadyPromise: Promise<void> | null = null;
 
 /** Lazily create a Qdrant REST client bound to the resolved URL. */
 function getClient(): QdrantRestClient {
@@ -85,7 +86,15 @@ function getClient(): QdrantRestClient {
  */
 export async function ensureConceptPageCollection(): Promise<void> {
   if (_collectionReady) return;
+  if (_collectionReadyPromise) return _collectionReadyPromise;
 
+  _collectionReadyPromise = ensureConceptPageCollectionOnce().finally(() => {
+    _collectionReadyPromise = null;
+  });
+  return _collectionReadyPromise;
+}
+
+async function ensureConceptPageCollectionOnce(): Promise<void> {
   const client = getClient();
   const config = getConfig();
   const vectorSize = config.memory.qdrant.vectorSize;
@@ -215,6 +224,95 @@ export async function deleteConceptPageEmbedding(slug: string): Promise<void> {
   }
 }
 
+/**
+ * Remove every point whose slug starts with the given prefix and whose
+ * remaining suffix is not in `activeSuffixes`. Used by the skill-seed flow to
+ * drop stale `skills/<id>` slugs after a skill is uninstalled or disabled,
+ * since skills now share the concept-page collection rather than living in a
+ * dedicated one.
+ *
+ * Idempotent: when the live `<prefix>*` slugs already match `activeSuffixes`,
+ * the function performs a single scroll and no deletes.
+ */
+export async function pruneSlugsWithPrefixExcept(
+  prefix: string,
+  activeSuffixes: readonly string[],
+): Promise<void> {
+  await ensureConceptPageCollection();
+
+  const client = getClient();
+  const activeSet = new Set(activeSuffixes);
+
+  const doPrune = async (): Promise<void> => {
+    const stalePointIds: Array<string | number> = [];
+    let offset: string | number | undefined = undefined;
+    const maxIterations = 10_000;
+    const batchSize = 256;
+    for (let i = 0; i < maxIterations; i++) {
+      const result = await client.scroll(MEMORY_V2_COLLECTION, {
+        limit: batchSize,
+        with_payload: true,
+        with_vector: false,
+        ...(offset !== undefined ? { offset } : {}),
+      });
+      for (const point of result.points) {
+        const slug = (point.payload as { slug?: unknown } | null)?.slug;
+        if (typeof slug !== "string") continue;
+        if (!slug.startsWith(prefix)) continue;
+        const suffix = slug.slice(prefix.length);
+        if (!activeSet.has(suffix)) {
+          stalePointIds.push(point.id);
+        }
+      }
+      const next = result.next_page_offset;
+      if (next == null) break;
+      offset = typeof next === "string" ? next : (next as number);
+    }
+
+    if (stalePointIds.length === 0) return;
+
+    await client.delete(MEMORY_V2_COLLECTION, {
+      wait: true,
+      points: stalePointIds,
+    });
+  };
+
+  try {
+    await doPrune();
+  } catch (err) {
+    if (isCollectionMissing(err)) {
+      _collectionReady = false;
+      await ensureConceptPageCollection();
+      await doPrune();
+      return;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Best-effort delete of the legacy `memory_v2_skills` Qdrant collection. Skill
+ * embeddings now live alongside concept pages in `memory_v2_concept_pages`
+ * under the `skills/<id>` slug prefix, so the dedicated collection is dead
+ * weight on installs upgraded from the split-collection era. Fire-and-forget:
+ * on a fresh install (collection never existed) or a transient Qdrant
+ * unavailable, we log and move on.
+ */
+export async function dropLegacySkillsCollection(): Promise<void> {
+  try {
+    const client = getClient();
+    const exists = await client.collectionExists("memory_v2_skills");
+    if (!exists.exists) return;
+    await client.deleteCollection("memory_v2_skills");
+    log.info("Deleted legacy memory_v2_skills Qdrant collection");
+  } catch (err) {
+    log.warn(
+      { err },
+      "Failed to drop legacy memory_v2_skills collection — non-fatal",
+    );
+  }
+}
+
 /**
  * Run separate dense and sparse queries against the concept-page collection
  * and return per-channel scores per slug. Callers fuse these — typically via
@@ -437,4 +535,5 @@ function pointIdForSlug(slug: string): string {
 export function _resetMemoryV2QdrantForTests(): void {
   _client = null;
   _collectionReady = false;
+  _collectionReadyPromise = null;
 }

package/src/memory/v2/reranker.ts

@@ -0,0 +1,177 @@
+/** Memory v2 cross-encoder rerank — `(query, page-preview)` pairs scored by a local model. */
+
+import { createHash } from "node:crypto";
+
+import type { AssistantConfig } from "../../config/types.js";
+import { getLogger } from "../../util/logger.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import { getOrCreateRerankBackend } from "../rerank-local.js";
+import { readPage } from "./page-store.js";
+
+const log = getLogger("memory-v2-reranker");
+
+// ~512-token model context for bge-reranker-base; cap input to bound payload.
+const PASSAGE_CHAR_CAP = 240;
+
+interface CacheEntry {
+  scores: Map<string, number>;
+  ts: number;
+}
+
+const CACHE_TTL_MS = 2 * 60 * 1000;
+const CACHE_MAX_ENTRIES = 64;
+const cache = new Map<string, CacheEntry>();
+
+function cacheKey(query: string, slugs: readonly string[]): string {
+  const sorted = [...slugs].sort().join("\0");
+  return createHash("sha256").update(`${query}\0${sorted}`).digest("hex");
+}
+
+function evictExpired(now: number): void {
+  for (const [k, v] of cache) {
+    if (now - v.ts > CACHE_TTL_MS) cache.delete(k);
+  }
+  if (cache.size > CACHE_MAX_ENTRIES) {
+    const toDrop = cache.size - CACHE_MAX_ENTRIES;
+    let i = 0;
+    for (const k of cache.keys()) {
+      if (i++ >= toDrop) break;
+      cache.delete(k);
+    }
+  }
+}
+
+function buildPassage(slug: string, body: string): string {
+  const trimmed = body.replace(/^\s+/, "");
+  const blank = trimmed.search(/\n\s*\n/);
+  const para = blank === -1 ? trimmed : trimmed.slice(0, blank);
+  const stripped = para.replace(/^#+\s.*\n/, "").trim();
+  const compact = stripped.replace(/\s+/g, " ").slice(0, PASSAGE_CHAR_CAP);
+  return `${slug}\n${compact}`;
+}
+
+/**
+ * Run the cross-encoder over each candidate's first-paragraph preview for
+ * one or more queries against the same candidate set. Returns one
+ * `Map<slug, score>` per query, in the same order as the `queries` array.
+ *
+ * Multi-query batching: the user-channel and assistant-channel queries share
+ * a candidate set per turn, so scoring them in a single tokenizer +
+ * forward-pass call avoids the ONNX-invocation overhead of two serialised
+ * worker round-trips. Cache hits short-circuit per-query independently —
+ * a whitespace-only query yields an empty Map without hitting the backend.
+ *
+ * Failures (worker down, page read errors) yield empty Maps so callers can
+ * fall back to pure fused scores. Per-batch normalisation and boost math
+ * live in `computeOwnActivation`.
+ */
+export async function rerankCandidates(
+  queries: readonly string[],
+  candidates: readonly string[],
+  config: AssistantConfig,
+): Promise<Array<Map<string, number>>> {
+  if (queries.length === 0) return [];
+  if (candidates.length === 0) return queries.map(() => new Map());
+
+  const now = Date.now();
+  evictExpired(now);
+
+  const results: Array<Map<string, number> | null> = queries.map(() => null);
+  const uncachedIndices: number[] = [];
+  for (let i = 0; i < queries.length; i++) {
+    const q = queries[i];
+    if (q.trim().length === 0) {
+      results[i] = new Map();
+      continue;
+    }
+    const key = cacheKey(q, candidates);
+    const cached = cache.get(key);
+    if (cached) {
+      // Refresh insertion order so frequently-hit entries survive eviction.
+      cache.delete(key);
+      cache.set(key, { ...cached, ts: now });
+      results[i] = new Map(cached.scores);
+    } else {
+      uncachedIndices.push(i);
+    }
+  }
+
+  const finalize = (): Array<Map<string, number>> =>
+    results.map((r) => r ?? new Map());
+
+  if (uncachedIndices.length === 0) return finalize();
+
+  const workspaceDir = getWorkspaceDir();
+  const pages = await Promise.all(
+    candidates.map((slug) =>
+      readPage(workspaceDir, slug).catch((err) => {
+        log.debug({ err, slug }, "Reranker skipping page that failed to load");
+        return null;
+      }),
+    ),
+  );
+  const passages: string[] = [];
+  const slugsForPassages: string[] = [];
+  for (let i = 0; i < candidates.length; i++) {
+    const page = pages[i];
+    if (!page) continue;
+    passages.push(buildPassage(candidates[i], page.body));
+    slugsForPassages.push(candidates[i]);
+  }
+
+  if (passages.length === 0) {
+    for (const i of uncachedIndices) results[i] = new Map();
+    return finalize();
+  }
+
+  // One tokenizer + ONNX forward pass over every uncached query × passage
+  // pair. Pairs are laid out query-major: queries[uncached[0]] × passages,
+  // then queries[uncached[1]] × passages, etc.
+  const batchQueries: string[] = [];
+  const batchPassages: string[] = [];
+  for (const qi of uncachedIndices) {
+    const q = queries[qi];
+    for (const p of passages) {
+      batchQueries.push(q);
+      batchPassages.push(p);
+    }
+  }
+
+  const { model, dtype } = config.memory.v2.rerank;
+  let scores: number[];
+  try {
+    const backend = getOrCreateRerankBackend(model, dtype);
+    scores = await backend.score(batchQueries, batchPassages);
+  } catch (err) {
+    log.warn(
+      { err, model, n: batchPassages.length },
+      "Rerank backend failed; falling back to pure fused scores",
+    );
+    for (const i of uncachedIndices) results[i] = new Map();
+    return finalize();
+  }
+
+  for (let j = 0; j < uncachedIndices.length; j++) {
+    const qi = uncachedIndices[j];
+    const offset = j * passages.length;
+    const result = new Map<string, number>();
+    for (let i = 0; i < slugsForPassages.length; i++) {
+      const s = scores[offset + i];
+      if (typeof s !== "number" || Number.isNaN(s)) continue;
+      // sigmoid output should already be in [0, 1]; clamp defensively.
+      result.set(slugsForPassages[i], Math.max(0, Math.min(1, s)));
+    }
+    results[qi] = result;
+    cache.set(cacheKey(queries[qi], candidates), {
+      scores: new Map(result),
+      ts: now,
+    });
+  }
+
+  return finalize();
+}
+
+/** @internal Test-only: clear the LRU cache. */
+export function _resetRerankCacheForTests(): void {
+  cache.clear();
+}