@vellumai/assistant 0.7.1 → 0.7.3

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
@@ -236,6 +334,7 @@ export async function hybridQueryConceptPages(
   sparse: SparseEmbedding,
   limit: number,
   restrictToSlugs?: readonly string[],
+  options?: { skipSparse?: boolean },
 ): Promise<ConceptPageQueryResult[]> {
   if (restrictToSlugs && restrictToSlugs.length === 0) {
     // An empty restriction means "no candidates"; skip the round-trip.
@@ -249,6 +348,13 @@ export async function hybridQueryConceptPages(
     ? { must: [{ key: "slug", match: { any: [...restrictToSlugs] } }] }
     : undefined;
 
+  // When the caller weighted sparse to zero, skip the round-trip entirely.
+  // The downstream fuser (`fuseHit` in `sim.ts`) already treats a missing
+  // sparse score as a 0 contribution, so omitting the query is a pure
+  // optimization — and it's also the kill switch operators use to dodge a
+  // Qdrant 1.13.x sparse-index crash that we've reproduced in the wild.
+  const skipSparse = options?.skipSparse ?? false;
+
   const denseQuery = () =>
     client.query(MEMORY_V2_COLLECTION, {
       query: dense,
@@ -267,7 +373,14 @@ export async function hybridQueryConceptPages(
     });
 
   // Run both queries concurrently — they hit independent named vectors.
-  const runQueries = async () => Promise.all([denseQuery(), sparseQuery()]);
+  // When sparse is gated off we still resolve a Promise so the destructuring
+  // below stays uniform; the empty `points: []` matches the shape of a
+  // no-hit Qdrant response.
+  const emptyResult = {
+    points: [] as Array<{ payload?: unknown; score?: number }>,
+  };
+  const runQueries = async () =>
+    Promise.all([denseQuery(), skipSparse ? emptyResult : sparseQuery()]);
 
   let denseResults;
   let sparseResults;
@@ -305,6 +418,89 @@ export async function hybridQueryConceptPages(
   return Array.from(merged.values());
 }
 
+/**
+ * Page through the v2 concept-page collection and return up to `maxSamples`
+ * stored dense vectors. Used by the anisotropy-fit pipeline to compute a
+ * corpus mean + top-k principal components without re-embedding every page.
+ *
+ * Sparse vectors are skipped — anisotropy is a dense-embedding phenomenon, and
+ * pulling the sparse side would just inflate the response. Payload is also
+ * skipped because the fit doesn't need slug identity.
+ *
+ * Returns an empty array when the collection is empty or missing. Caller
+ * decides what to do (typically: surface a "no vectors to fit" error).
+ */
+export async function sampleConceptPageDenseVectors(
+  maxSamples: number,
+): Promise<number[][]> {
+  if (maxSamples <= 0) return [];
+  await ensureConceptPageCollection();
+
+  const client = getClient();
+  const out: number[][] = [];
+  let offset: string | number | undefined = undefined;
+  // Same pagination guard pattern as the rest of the file — bounds the loop
+  // even if Qdrant somehow keeps handing back a non-null offset.
+  const maxIterations = 10_000;
+  const batchSize = Math.min(256, maxSamples);
+
+  for (let i = 0; i < maxIterations; i++) {
+    if (out.length >= maxSamples) break;
+    const remaining = maxSamples - out.length;
+    let result;
+    try {
+      result = await client.scroll(MEMORY_V2_COLLECTION, {
+        limit: Math.min(batchSize, remaining),
+        with_payload: false,
+        // Fetch only the dense named vector — sparse is irrelevant for
+        // anisotropy correction.
+        with_vector: ["dense"],
+        ...(offset !== undefined ? { offset } : {}),
+      });
+    } catch (err) {
+      if (isCollectionMissing(err)) {
+        _collectionReady = false;
+        return out;
+      }
+      throw err;
+    }
+
+    for (const point of result.points) {
+      const v = extractDenseVector(point.vector);
+      if (v) out.push(v);
+      if (out.length >= maxSamples) break;
+    }
+
+    const next = result.next_page_offset;
+    if (next == null) break;
+    offset = typeof next === "string" ? next : (next as number);
+  }
+
+  return out;
+}
+
+/**
+ * Pull the `dense` named-vector payload out of a Qdrant point. Defensively
+ * handles both the named-vector shape (`{ dense: [...] }`) and the legacy
+ * unnamed-vector shape (`number[]`) so older collection layouts don't trip
+ * the sampler. Returns `null` for shapes we don't recognise.
+ */
+function extractDenseVector(vector: unknown): number[] | null {
+  if (Array.isArray(vector)) {
+    if (vector.every((n) => typeof n === "number")) {
+      return vector as number[];
+    }
+    return null;
+  }
+  if (vector && typeof vector === "object") {
+    const dense = (vector as { dense?: unknown }).dense;
+    if (Array.isArray(dense) && dense.every((n) => typeof n === "number")) {
+      return dense as number[];
+    }
+  }
+  return null;
+}
+
 /**
  * Detect "collection not found" errors so callers can reset readiness and
  * retry after an external deletion (e.g. workspace reset).
@@ -339,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();
+}

package/src/memory/v2/sim.ts

@@ -26,13 +26,11 @@
 //   only as a per-turn ordering signal, not compared across turns.
 
 import type { AssistantConfig } from "../../config/types.js";
-import {
-  embedWithBackend,
-  generateSparseEmbedding,
-} from "../embedding-backend.js";
+import { applyCorrectionIfCalibrated } from "../anisotropy.js";
+import { embedWithBackend } from "../embedding-backend.js";
 import { clampUnitInterval } from "../validation.js";
 import { hybridQueryConceptPages } from "./qdrant.js";
-import { hybridQuerySkills } from "./skill-qdrant.js";
+import { generateBm25QueryEmbedding } from "./sparse-bm25.js";
 
 /**
  * Clamp a value into the closed unit interval [0, 1]. Re-exported under the
@@ -40,6 +38,79 @@ import { hybridQuerySkills } from "./skill-qdrant.js";
  */
 export const clamp01 = clampUnitInterval;
 
+/**
+ * Built-in defaults for adaptive sparse weighting. Live here (not in the
+ * config schema) so operators don't see two new knobs in their config until
+ * they actually want to tune them.
+ *
+ * Below `MIN_SPREAD`, the sparse channel is treated as no-signal (its scores
+ * are uniform across the candidate set, so it can't rank anything) and the
+ * sparse weight collapses to 0. At or above `FULL_SPREAD`, sparse weight
+ * stays at its configured value. Linear interpolation between.
+ */
+const ADAPTIVE_SPARSE_MIN_SPREAD = 0.2;
+const ADAPTIVE_SPARSE_FULL_SPREAD = 0.5;
+
+/**
+ * Per-query effective dense + sparse weights, derived from the configured
+ * base weights and the spread of normalized sparse scores across the hit
+ * set. When the sparse channel can't discriminate (low spread or fewer
+ * than two sparse-bearing candidates), its weight collapses and dense
+ * weight is boosted to compensate so `dense + sparse` still equals
+ * `baseDense + baseSparse` and `fused` stays interpretable as a [0, 1]
+ * similarity.
+ *
+ * Pure function — exported so the diagnostic surface in
+ * `memory-v2-routes.explain-similarity` can show the effective weights and
+ * the measured spread alongside per-channel score statistics.
+ */
+export function effectiveWeights(
+  hits: ReadonlyArray<{ sparseScore?: number }>,
+  maxSparse: number,
+  baseDense: number,
+  baseSparse: number,
+  config: AssistantConfig,
+): { dense: number; sparse: number; spread: number } {
+  // Short-circuit when the channel is already disabled or unscored. Returning
+  // base weights here keeps `fused` numerically identical to today's output
+  // for the no-sparse-signal cases the existing tests assume.
+  if (baseSparse === 0 || maxSparse === 0) {
+    return { dense: baseDense, sparse: baseSparse, spread: 0 };
+  }
+  let min = Infinity;
+  let max = -Infinity;
+  let count = 0;
+  for (const h of hits) {
+    if (h.sparseScore === undefined) continue;
+    const norm = h.sparseScore / maxSparse;
+    if (norm < min) min = norm;
+    if (norm > max) max = norm;
+    count++;
+  }
+  // With < 2 sparse-bearing hits the spread is undefined — fall back to base
+  // weights so single-hit retrievals still surface their sparse contribution
+  // (and the existing fusion-math tests stay green).
+  if (count < 2) {
+    return { dense: baseDense, sparse: baseSparse, spread: 0 };
+  }
+  const spread = max - min;
+
+  const minSpread =
+    config.memory.v2.min_sparse_spread ?? ADAPTIVE_SPARSE_MIN_SPREAD;
+  const fullSpread =
+    config.memory.v2.full_sparse_spread ?? ADAPTIVE_SPARSE_FULL_SPREAD;
+  // Degenerate config (full <= min): no interpolation range. Don't try to
+  // adapt; trust the operator's base weights and report the measured spread
+  // for diagnostics.
+  if (fullSpread <= minSpread) {
+    return { dense: baseDense, sparse: baseSparse, spread };
+  }
+  const factor = clamp01((spread - minSpread) / (fullSpread - minSpread));
+  const sparse = baseSparse * factor;
+  const dense = baseDense + (baseSparse - sparse);
+  return { dense, sparse, spread };
+}
+
 /**
  * Compute hybrid (dense + sparse) similarity scores between a query text and
  * a fixed set of candidate concept-page slugs.
@@ -63,23 +134,41 @@ export const clamp01 = clampUnitInterval;
  * Edge cases:
  *   - Empty `candidateSlugs` → returns an empty map without touching Qdrant
  *     or the embedding backend.
- *   - Empty query text or all-zero sparse vector → still queries (dense may
- *     still hit), and the sparse contribution to fusion is zero.
+ *   - Empty / whitespace-only `text` → returns an empty map without touching
+ *     Qdrant or the embedding backend. The Gemini embedding API rejects empty
+ *     content with HTTP 400, and short-circuiting here prevents the failure
+ *     from cascading through `Promise.all` in `computeOwnActivation` (e.g.
+ *     turn 1 has no prior assistant message, so its `simBatch` channel is
+ *     called with `""`). Treating the channel's contribution as 0 is the
+ *     same outcome a no-hit query would produce.
  */
 export async function simBatch(
   text: string,
   candidateSlugs: readonly string[],
   config: AssistantConfig,
+  options?: { signal?: AbortSignal },
 ): Promise<Map<string, number>> {
   if (candidateSlugs.length === 0) {
     return new Map();
   }
+  if (text.trim().length === 0) {
+    return new Map();
+  }
 
-  // Sparse uses the shared TF-IDF encoder so the query and stored vectors
-  // share a vocabulary with PKB indexing.
-  const denseResult = await embedWithBackend(config, [text]);
-  const denseVector = denseResult.vectors[0];
-  const sparseVector = generateSparseEmbedding(text);
+  // Sparse uses BM25: the query side encodes binary occurrences per token,
+  // and the stored doc vectors carry the IDF · TF-saturated weights — Qdrant
+  // dot product then yields the BM25 score directly.
+  throwIfAborted(options?.signal);
+  const denseResult = await embedWithBackend(config, [text], {
+    signal: options?.signal,
+  });
+  const denseVector = await applyCorrectionIfCalibrated(
+    denseResult.vectors[0],
+    denseResult.provider,
+    denseResult.model,
+  );
+  throwIfAborted(options?.signal);
+  const sparseVector = generateBm25QueryEmbedding(text);
 
   const hits = await hybridQueryConceptPages(
     denseVector,
@@ -93,81 +182,28 @@ export async function simBatch(
   }
 
   const maxSparse = computeMaxSparse(hits);
-  const { dense_weight: denseWeight, sparse_weight: sparseWeight } =
+  const { dense_weight: baseDense, sparse_weight: baseSparse } =
     config.memory.v2;
+  const { dense: denseWeight, sparse: sparseWeight } = effectiveWeights(
+    hits,
+    maxSparse,
+    baseDense,
+    baseSparse,
+    config,
+  );
 
   const scores = new Map<string, number>();
   for (const hit of hits) {
     scores.set(hit.slug, fuseHit(hit, maxSparse, denseWeight, sparseWeight));
   }
+
   return scores;
 }
 
-/**
- * Compute hybrid (dense + sparse) similarity scores between a query text and
- * a fixed set of candidate skill ids. Mirrors `simBatch` but targets the
- * dedicated `memory_v2_skills` Qdrant collection via `hybridQuerySkills`.
- *
- * Differences from `simBatch`:
- *   - Keys are skill `id` values (not concept-page slugs).
- *   - Restricts the query to the caller's candidate ids server-side via
- *     `hybridQuerySkills`'s `restrictToIds` parameter. Without this, when the
- *     skills collection has more skills than `ids.length`, Qdrant would
- *     return its global top-K and candidate ids absent from that top-K would
- *     silently score 0 — corrupting the activation calculation.
- *
- * Returns a `Map<id, score>` of fused scores in [0, 1]. Ids that did not hit
- * either channel are absent from the map.
- *
- * Edge cases:
- *   - Empty `ids` → returns an empty map without touching Qdrant or the
- *     embedding backend.
- *   - Empty query text → still queries (dense may still hit), and the sparse
- *     contribution is zero.
- */
-export async function simSkillBatch(
-  text: string,
-  ids: readonly string[],
-  config: AssistantConfig,
-): Promise<Map<string, number>> {
-  if (ids.length === 0) {
-    return new Map();
-  }
-
-  const denseResult = await embedWithBackend(config, [text]);
-  const denseVector = denseResult.vectors[0];
-  const sparseVector = generateSparseEmbedding(text);
-
-  const hits = await hybridQuerySkills(
-    denseVector,
-    sparseVector,
-    ids.length,
-    ids,
-  );
-
-  if (hits.length === 0) {
-    return new Map();
-  }
-
-  // Defensive post-filter — `hybridQuerySkills` restricts server-side, so
-  // every hit should already be in `ids`, but keep this guard so a buggy
-  // payload (e.g. a missing/typoed id index) can't silently inject
-  // out-of-set ids into the score map.
-  const idSet = new Set(ids);
-  const filtered = hits.filter((h) => idSet.has(h.id));
-  if (filtered.length === 0) {
-    return new Map();
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
   }
-
-  const maxSparse = computeMaxSparse(filtered);
-  const { dense_weight: denseWeight, sparse_weight: sparseWeight } =
-    config.memory.v2;
-
-  const scores = new Map<string, number>();
-  for (const hit of filtered) {
-    scores.set(hit.id, fuseHit(hit, maxSparse, denseWeight, sparseWeight));
-  }
-  return scores;
 }
 
 /**

package/src/memory/v2/skill-content.ts

@@ -2,9 +2,10 @@ import { getConfig } from "../../config/loader.js";
 import type { SkillCapabilityInput } from "../../skills/skill-memory.js";
 
 /**
- * Render the prose-style capability statement embedded into the
- * `memory_v2_skills` Qdrant collection and rendered in
- * `### Skills You Can Use`. Capped at 500 chars to match v1's behavior.
+ * Render the prose-style capability statement embedded into the unified
+ * `memory_v2_concept_pages` Qdrant collection (under the `skills/<id>` slug
+ * prefix) and rendered in `### Skills You Can Use`. Capped at 500 chars to
+ * match v1's behavior.
  */
 export function buildSkillContent(input: SkillCapabilityInput): string {
   let content = `The "${input.displayName}" skill (${input.id}) is available. ${input.description}.`;