@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -0,0 +1,195 @@
+/**
+ * Memory v2 — router prompt template.
+ *
+ * The router runs once per assistant turn and decides which concept pages (if
+ * any) should be injected on top of the always-on essentials/threads/recent
+ * block. The body lives here (under `prompts/`) so it is reviewable on its
+ * own, mirroring the convention established in `sweep.ts`.
+ *
+ * Three placeholders are substituted at runtime:
+ *
+ *   - `{{ASSISTANT_NAME}}` — assistant display name (from IDENTITY.md when
+ *     available, else the neutral fallback "the assistant").
+ *   - `{{USER_NAME}}` — guardian display name (from the guardian persona when
+ *     available, else "the user").
+ *   - `{{PAGE_INDEX}}` — pre-rendered page index. Each line has the shape
+ *     `[id] slug — summary (edges: a, b, c)` where edges are numeric IDs into
+ *     the same list. The caller renders this so the prompt module stays
+ *     stateless.
+ *
+ * Operators may replace the bundled body via
+ * `memory.v2.router.router_prompt_path` and {@link resolveRouterPrompt} — the
+ * same placeholder substitution applies to overrides.
+ */
+
+import { lstatSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+
+import { getLogger } from "../../../util/logger.js";
+
+const log = getLogger("memory-v2-router-prompt");
+
+/**
+ * Hard upper bound on the override file size. The bundled prompt is well
+ * under 4 KiB; 1 MiB is generous-enough for any reasonable hand-edit while
+ * still preventing pathological inputs from being slurped into memory on
+ * every router call.
+ */
+const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
+
+/** Sentinel substituted with the assistant's display name at runtime. */
+const ASSISTANT_NAME_PLACEHOLDER = "{{ASSISTANT_NAME}}";
+
+/** Sentinel substituted with the guardian's display name at runtime. */
+const USER_NAME_PLACEHOLDER = "{{USER_NAME}}";
+
+/** Sentinel substituted with the rendered page index block at runtime. */
+const PAGE_INDEX_PLACEHOLDER = "{{PAGE_INDEX}}";
+
+/**
+ * Router prompt — picks at most a handful of concept pages to inject for the
+ * next assistant turn. The model emits a `select_pages_to_inject` tool call
+ * with a `page_ids` array; the runtime parses the response via the tool
+ * definition declared in the router job module.
+ *
+ * Recent message context and `<now>` / `<already_injected_ids>` blocks are
+ * appended at the call site so we don't inadvertently expand `{{` inside
+ * dynamic content.
+ */
+const ROUTER_PROMPT = `You are a background helper for ${ASSISTANT_NAME_PLACEHOLDER}. Your job is to route memory pages for the next assistant turn between ${ASSISTANT_NAME_PLACEHOLDER} and ${USER_NAME_PLACEHOLDER}.
+
+You will be shown the recent conversation, a \`<now>\` marker for the current time, an \`<already_injected_ids>\` block listing pages picked on the previous turn, and a \`# Concept Page Index\` listing every routable page on this workspace.
+
+Pick the concept pages whose contents would help ${ASSISTANT_NAME_PLACEHOLDER} respond well on this turn. Lean toward inclusion when in doubt — missing a relevant page is a worse error than surfacing a few unused ones, because the assistant can ignore extras but can't summon context that wasn't loaded. Abstain (return an empty list) only when nothing in the index plausibly bears on the turn.
+
+Index format. Each line of the index has the shape:
+
+    [id] slug — summary (edges: a, b, c)
+
+\`id\` is a small integer used to refer to this page. \`edges\` are numeric IDs into the same list, pointing at related pages; you may follow them when one page strongly implies another.
+
+Already-injected pages. Pages whose IDs appear in \`<already_injected_ids>\` were picked on the previous turn. Do not pick them again unless ${ASSISTANT_NAME_PLACEHOLDER} should re-anchor on that material — e.g., the topic genuinely returns after drifting away. Routine continuity does not require re-picking; the prior turn's pages are already in the assistant's working context.
+
+Time. Bias toward pages that match the current state implied by \`<now>\` and the active conversational threads (what is happening today, what was just decided, who is being discussed). Stale pages with no bearing on the live conversation should be skipped even if their summaries look superficially relevant.
+
+Emit your selection by calling \`select_pages_to_inject\` with the chosen \`page_ids\`. Return an empty array to abstain.
+
+# Concept Page Index
+
+${PAGE_INDEX_PLACEHOLDER}`;
+
+interface RenderRouterPromptOpts {
+  assistantName: string | null;
+  userName: string | null;
+  pageIndexBlock: string;
+}
+
+/**
+ * Resolve `ROUTER_PROMPT` with assistant name, user name, and the rendered
+ * page index substituted in. Falls back to neutral defaults so the prompt
+ * still produces well-formed English when either name is unavailable on this
+ * workspace. The page index is substituted verbatim — callers are responsible
+ * for trimming/formatting it.
+ */
+export function renderRouterPrompt(opts: RenderRouterPromptOpts): string {
+  return substitutePlaceholders(ROUTER_PROMPT, opts);
+}
+
+/**
+ * Load the router prompt template, optionally overridden from the file
+ * referenced by `memory.v2.router.router_prompt_path`, then substitute the
+ * standard placeholders. Path-resolution rules mirror the consolidation
+ * prompt override: absolute paths used as-is, leading `~/` expanded to home,
+ * relative paths resolved under `workspaceDir`.
+ *
+ * Failure handling is intentionally permissive — missing file, read error,
+ * oversized file, or empty/whitespace-only body all log a warning and fall
+ * back to the bundled prompt. Router selection must never break because of
+ * a bad override.
+ */
+export function resolveRouterPrompt(
+  overridePath: string | null,
+  workspaceDir: string,
+  opts: RenderRouterPromptOpts,
+): string {
+  if (overridePath === null) return renderRouterPrompt(opts);
+
+  const resolvedPath = resolveOverridePath(overridePath, workspaceDir);
+  let contents: string;
+  try {
+    const stat = lstatSync(resolvedPath);
+    if (!stat.isFile()) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          reason: "not_regular_file",
+          fallback: "bundled",
+        },
+        "router prompt override is not a regular file; using bundled prompt",
+      );
+      return renderRouterPrompt(opts);
+    }
+    if (stat.size > MAX_PROMPT_BYTES) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          size: stat.size,
+          limit: MAX_PROMPT_BYTES,
+          reason: "oversized_override",
+          fallback: "bundled",
+        },
+        "router prompt override exceeds size limit; using bundled prompt",
+      );
+      return renderRouterPrompt(opts);
+    }
+    contents = readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    log.warn(
+      { configuredPath: overridePath, resolvedPath, code, fallback: "bundled" },
+      "router prompt override unreadable; using bundled prompt",
+    );
+    return renderRouterPrompt(opts);
+  }
+
+  if (contents.trim().length === 0) {
+    log.warn(
+      {
+        configuredPath: overridePath,
+        resolvedPath,
+        reason: "empty_override",
+        fallback: "bundled",
+      },
+      "router prompt override is empty; using bundled prompt",
+    );
+    return renderRouterPrompt(opts);
+  }
+
+  return substitutePlaceholders(contents, opts);
+}
+
+function substitutePlaceholders(
+  template: string,
+  opts: RenderRouterPromptOpts,
+): string {
+  const assistant = opts.assistantName?.trim() || "the assistant";
+  const user = opts.userName?.trim() || "the user";
+  return template
+    .replaceAll(ASSISTANT_NAME_PLACEHOLDER, () => assistant)
+    .replaceAll(USER_NAME_PLACEHOLDER, () => user)
+    .replaceAll(PAGE_INDEX_PLACEHOLDER, () => opts.pageIndexBlock);
+}
+
+function resolveOverridePath(
+  overridePath: string,
+  workspaceDir: string,
+): string {
+  if (overridePath.startsWith("~/")) {
+    return join(homedir(), overridePath.slice(2));
+  }
+  if (isAbsolute(overridePath)) return overridePath;
+  return join(workspaceDir, overridePath);
+}

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

@@ -51,6 +51,6 @@ export function renderSweepPrompt(opts: {
   const user = opts.userName?.trim() || "the user";
   return SWEEP_PROMPT.replaceAll(
     ASSISTANT_NAME_PLACEHOLDER,
-    assistant,
-  ).replaceAll(USER_NAME_PLACEHOLDER, user);
+    () => assistant,
+  ).replaceAll(USER_NAME_PLACEHOLDER, () => user);
 }

package/src/memory/v2/qdrant.ts

@@ -18,11 +18,16 @@
 // fusion using `dense_weight` / `sparse_weight` from `config.memory.v2`,
 // which RRF fusion would discard.
 
+import { existsSync } from "node:fs";
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
 import { QdrantClient as QdrantRestClient } from "@qdrant/js-client-rest";
 import { v5 as uuidv5 } from "uuid";
 
 import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
+import { getDataDir } from "../../util/platform.js";
 import type { SparseEmbedding } from "../embedding-types.js";
 import { resolveQdrantUrl } from "../qdrant-client.js";
 
@@ -86,6 +91,49 @@ let _collectionReadyPromise: Promise<{ migrated: boolean }> | null = null;
 const REQUIRED_DENSE_VECTORS = ["dense", "summary_dense"] as const;
 const REQUIRED_SPARSE_VECTORS = ["sparse", "summary_sparse"] as const;
 
+/**
+ * Marker file written before the destructive collection-recreate path runs,
+ * cleared by the lifecycle hook once the reembed job has been enqueued.
+ *
+ * The sentinel exists to close a narrow data-loss window in
+ * `ensureConceptPageCollectionOnce`: a transient Qdrant failure between
+ * `deleteCollection` and `createCollection` would otherwise lose the
+ * "needs reembed" signal — `migrated` is reinitialized on the next call,
+ * any subsequent caller (e.g. an upsert) recreates the collection empty,
+ * and the lifecycle hook never enqueues the backfill. By persisting the
+ * intent on disk *before* delete, the signal survives crashes and
+ * intra-process retries: every later `ensureConceptPageCollection` call
+ * returns `migrated: true` until the lifecycle hook enqueues the reembed
+ * and clears the sentinel.
+ */
+const REEMBED_SENTINEL_FILENAME = ".memory-v2-reembed-required";
+
+function reembedSentinelPath(): string {
+  return join(getDataDir(), REEMBED_SENTINEL_FILENAME);
+}
+
+function reembedSentinelExists(): boolean {
+  return existsSync(reembedSentinelPath());
+}
+
+async function writeReembedSentinel(): Promise<void> {
+  const path = reembedSentinelPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, "");
+}
+
+/**
+ * Remove the reembed sentinel after the lifecycle hook has enqueued the
+ * `memory_v2_reembed` job. Idempotent — missing-file is not an error.
+ */
+export async function clearReembedSentinel(): Promise<void> {
+  try {
+    await unlink(reembedSentinelPath());
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+}
+
 /** Lazily create a Qdrant REST client bound to the resolved URL. */
 function getClient(): QdrantRestClient {
   if (_client) return _client;
@@ -127,7 +175,11 @@ async function ensureConceptPageCollectionOnce(): Promise<{
   const vectorSize = config.memory.qdrant.vectorSize;
   const onDisk = config.memory.qdrant.onDisk;
 
-  let migrated = false;
+  // A leftover sentinel means a prior call deleted the collection but never
+  // got to enqueue the reembed (e.g. createCollection threw, or the process
+  // died mid-rebuild). Carry that signal forward until the lifecycle hook
+  // clears it.
+  let migrated = reembedSentinelExists();
 
   try {
     const exists = await client.collectionExists(MEMORY_V2_COLLECTION);
@@ -148,6 +200,9 @@ async function ensureConceptPageCollectionOnce(): Promise<{
 
       const missing = missingNamedVectors(info);
       if (missing.length === 0) {
+        // Long-lived installs may predate the `kind` payload index; ensure
+        // every required index exists before declaring the collection ready.
+        await ensurePayloadIndexes();
         _collectionReady = true;
         return { migrated: false };
       }
@@ -156,6 +211,10 @@ async function ensureConceptPageCollectionOnce(): Promise<{
         { collection: MEMORY_V2_COLLECTION, missingNamedVectors: missing },
         "Memory v2 concept-page collection schema drift detected — deleting and recreating; embeddings will be regenerated by background reembed",
       );
+      // Persist the reembed intent BEFORE the destructive delete so a crash
+      // (or transient createCollection failure) between delete and recreate
+      // still triggers reembed on the next ensure call.
+      await writeReembedSentinel();
       await client.deleteCollection(MEMORY_V2_COLLECTION);
       migrated = true;
       // Fall through to creation below.
@@ -215,17 +274,62 @@ async function ensureConceptPageCollectionOnce(): Promise<{
     throw err;
   }
 
-  // Slug is the only payload field we filter on; index it once at create-time
-  // so upserts and slug-restricted queries don't pay a per-call indexing cost.
-  await client.createPayloadIndex(MEMORY_V2_COLLECTION, {
-    field_name: "slug",
-    field_schema: "keyword",
-  });
+  await ensurePayloadIndexes();
 
   _collectionReady = true;
   return { migrated };
 }
 
+/**
+ * Idempotently create the payload indexes the collection's query and
+ * filter paths rely on:
+ *
+ *   - `slug` (keyword): every slug-restricted query and prefix scan filters on it.
+ *   - `kind` (keyword): the skill-backfill scroll filters with `is_empty` on
+ *     `kind`. Strict-mode Qdrant deployments reject filters on unindexed
+ *     payload fields, so without this the backfill consistently fails and
+ *     legacy skill points remain untagged.
+ *
+ * Same-schema `createPayloadIndex` calls are idempotent server-side in
+ * Qdrant (200 OK), so the only "already exists" failures we expect are
+ * narrow races where a concurrent caller created the same index a moment
+ * earlier. Those are benign and swallowed. Every other failure — strict-mode
+ * rejection, index-limit, transient network blip — must propagate so the
+ * caller does not latch readiness on a collection whose `slug`/`kind`
+ * filters will keep rejecting queries until the next daemon restart.
+ */
+async function ensurePayloadIndexes(): Promise<void> {
+  const client = getClient();
+  const indexes = [
+    { field_name: "slug", field_schema: "keyword" as const },
+    { field_name: "kind", field_schema: "keyword" as const },
+  ];
+  // Parallel so one "already exists" race on a single index doesn't stall
+  // the other create round-trip. v1's `qdrant-client.ts` uses the same
+  // Promise.all shape.
+  await Promise.all(
+    indexes.map(async (index) => {
+      try {
+        await client.createPayloadIndex(MEMORY_V2_COLLECTION, index);
+      } catch (err) {
+        if (isPayloadIndexAlreadyExists(err)) return;
+        throw err;
+      }
+    }),
+  );
+}
+
+/**
+ * True when a `createPayloadIndex` error indicates the index already
+ * exists with matching parameters — the only failure shape it is safe to
+ * swallow. Qdrant returns 4xx with messages like
+ * `"Wrong input: Payload field 'kind' already exists ..."`.
+ */
+function isPayloadIndexAlreadyExists(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /already exists/i.test(msg);
+}
+
 /**
  * Return the names of required named vectors absent from the collection's
  * current schema. An empty array means the collection is fully migrated.
@@ -279,10 +383,17 @@ export async function upsertConceptPageEmbedding(params: {
   sparse: SparseEmbedding;
   summary?: { dense: number[]; sparse: SparseEmbedding };
   updatedAt: number;
+  /**
+   * Optional payload discriminator. Used to distinguish skill-seeded points
+   * (`kind: "skill"`) from user-authored concept pages so namespace pruning
+   * via {@link pruneSlugsWithPrefixExcept} can scope deletes to a single kind.
+   * Omitted for plain concept pages.
+   */
+  kind?: string;
 }): Promise<void> {
   await ensureConceptPageCollection();
 
-  const { slug, dense, sparse, summary, updatedAt } = params;
+  const { slug, dense, sparse, summary, updatedAt, kind } = params;
   const client = getClient();
   const pointId = pointIdForSlug(slug);
 
@@ -296,6 +407,9 @@ export async function upsertConceptPageEmbedding(params: {
     vector.summary_sparse = summary.sparse;
   }
 
+  const payload: Record<string, unknown> = { slug, updated_at: updatedAt };
+  if (kind !== undefined) payload.kind = kind;
+
   const upsertOnce = () =>
     client.upsert(MEMORY_V2_COLLECTION, {
       wait: true,
@@ -303,7 +417,7 @@ export async function upsertConceptPageEmbedding(params: {
         {
           id: pointId,
           vector,
-          payload: { slug, updated_at: updatedAt },
+          payload,
         },
       ],
     });
@@ -352,17 +466,28 @@ export async function deleteConceptPageEmbedding(slug: string): Promise<void> {
  * since skills now share the concept-page collection rather than living in a
  * dedicated one.
  *
+ * `kind` scopes pruning to a payload discriminator: only points whose
+ * `payload.kind` matches are eligible for deletion. This is critical because
+ * `validateSlug` permits user-authored concept pages slugged like
+ * `skills/foo`; without a kind filter they would collide with the skill
+ * namespace and be repeatedly pruned every seed run. The companion
+ * {@link backfillKindOnPointsWithPrefix} preserves this invariant for legacy
+ * untagged rows by tagging only suffixes the caller knows are skills —
+ * user-authored `skills/<slug>` rows stay kindless and outside this prune.
+ *
  * 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[],
+  options: { kind?: string } = {},
 ): Promise<void> {
   await ensureConceptPageCollection();
 
   const client = getClient();
   const activeSet = new Set(activeSuffixes);
+  const requiredKind = options.kind;
 
   const doPrune = async (): Promise<void> => {
     const stalePointIds: Array<string | number> = [];
@@ -377,9 +502,15 @@ export async function pruneSlugsWithPrefixExcept(
         ...(offset !== undefined ? { offset } : {}),
       });
       for (const point of result.points) {
-        const slug = (point.payload as { slug?: unknown } | null)?.slug;
+        const payload = point.payload as {
+          slug?: unknown;
+          kind?: unknown;
+        } | null;
+        const slug = payload?.slug;
         if (typeof slug !== "string") continue;
         if (!slug.startsWith(prefix)) continue;
+        if (requiredKind !== undefined && payload?.kind !== requiredKind)
+          continue;
         const suffix = slug.slice(prefix.length);
         if (!activeSet.has(suffix)) {
           stalePointIds.push(point.id);
@@ -411,6 +542,83 @@ export async function pruneSlugsWithPrefixExcept(
   }
 }
 
+/**
+ * Set `payload.kind` on every point whose slug starts with `prefix`, whose
+ * suffix is in `allowedSuffixes`, and is currently missing the `kind`
+ * discriminator. Used to tag legacy rows that predate the kind field so the
+ * kind-scoped {@link pruneSlugsWithPrefixExcept} no longer leaves them as
+ * orphans.
+ *
+ * `allowedSuffixes` is required because `validateSlug` permits user-authored
+ * concept pages slugged like `skills/my-notes` — those rows also lack `kind`
+ * and would otherwise be tagged here and then deleted by the kind-scoped
+ * prune. Callers must pass the closed set of legitimate suffixes (e.g. the
+ * union of installed + remote-catalog skill IDs) so user pages stay untagged.
+ *
+ * The "missing kind" predicate is pushed to Qdrant via `is_empty`, so once
+ * every legacy row has been tagged the scroll returns the bounded set of
+ * other kindless concept pages without ever touching the already-tagged
+ * rows. Idempotent across retries: a row tagged by an earlier partial run
+ * no longer matches the filter and is silently skipped.
+ */
+export async function backfillKindOnPointsWithPrefix(
+  prefix: string,
+  kind: string,
+  allowedSuffixes: ReadonlySet<string>,
+): Promise<number> {
+  if (allowedSuffixes.size === 0) return 0;
+  await ensureConceptPageCollection();
+
+  const client = getClient();
+
+  const doBackfill = async (): Promise<number> => {
+    const pointIds: 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,
+        filter: { must: [{ is_empty: { key: "kind" } }] },
+        ...(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 (!allowedSuffixes.has(suffix)) continue;
+        pointIds.push(point.id);
+      }
+      const next = result.next_page_offset;
+      if (next == null) break;
+      offset = typeof next === "string" ? next : (next as number);
+    }
+
+    if (pointIds.length === 0) return 0;
+
+    await client.setPayload(MEMORY_V2_COLLECTION, {
+      payload: { kind },
+      points: pointIds,
+      wait: true,
+    });
+    return pointIds.length;
+  };
+
+  try {
+    return await doBackfill();
+  } catch (err) {
+    if (isCollectionMissing(err)) {
+      _collectionReady = false;
+      await ensureConceptPageCollection();
+      return await doBackfill();
+    }
+    throw err;
+  }
+}
+
 /**
  * Approximate count of points in the v2 concept-page collection. Used by the
  * daemon-startup rebuild hook to detect "collection exists but empty" — the
@@ -435,6 +643,22 @@ export async function countConceptPagePoints(): Promise<number> {
   }
 }
 
+/**
+ * Probe whether the v2 concept-page collection currently exists in Qdrant
+ * **without** triggering creation. Read-only diagnostics use this to avoid
+ * the side effect of bootstrapping storage just by inspecting it.
+ */
+export async function conceptPageCollectionExists(): Promise<boolean> {
+  const client = getClient();
+  try {
+    const result = await client.collectionExists(MEMORY_V2_COLLECTION);
+    return result.exists;
+  } catch (err) {
+    if (isCollectionMissing(err)) return false;
+    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`
@@ -579,89 +803,6 @@ 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).