@vellumai/assistant 0.8.1 → 0.8.2

package/src/memory/v2/page-index.ts

@@ -30,6 +30,16 @@ const log = getLogger("memory-v2-page-index");
 
 const SUMMARY_MAX_LENGTH = 200;
 
+/**
+ * Collapse every run of whitespace (including embedded newlines and tabs) to a
+ * single space and trim. The router prompt renders one entry per line, so an
+ * embedded newline anywhere in `summary` would split that entry across lines
+ * and corrupt the format the router parses.
+ */
+function normalizeSummary(raw: string): string {
+  return raw.replace(/\s+/g, " ").trim().slice(0, SUMMARY_MAX_LENGTH);
+}
+
 /**
  * One row in the rendered page index. `id` is a 1-based dense integer that is
  * stable within a single index version (i.e. a single build). It changes when
@@ -97,6 +107,21 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
     outgoingSlugs: string[];
   }
 
+  const { listSkillEntries, SKILL_SLUG_PREFIX } =
+    await import("./skill-store.js");
+
+  // Build the skill-slug set first so we can drop colliding concept pages.
+  // Collision policy: **skill entries win**. Skill rows are seeded from the
+  // curated catalog and the router needs them to be reachable under their
+  // canonical slugs; a hand-authored page sitting under `skills/<id>` is
+  // either a stale leftover from a prior write or a user mistake. `bySlug`
+  // is last-writer-wins, so without explicit dedupe one side would silently
+  // shadow the other depending on iteration order.
+  const skillEntries = listSkillEntries();
+  const skillSlugs = new Set(
+    skillEntries.map((entry) => `${SKILL_SLUG_PREFIX}${entry.id}`),
+  );
+
   const drafts: DraftEntry[] = [];
   for (let i = 0; i < settled.length; i++) {
     const result = settled[i];
@@ -110,20 +135,25 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
     }
     const page = result.value;
     if (!page) continue;
+    if (skillSlugs.has(slug)) {
+      log.warn(
+        { slug },
+        "Dropping concept page from index — slug collides with a seeded skill entry; skill wins",
+      );
+      continue;
+    }
     const summarySource = page.frontmatter.summary?.trim() || page.body.trim();
     drafts.push({
       slug,
-      summary: summarySource.slice(0, SUMMARY_MAX_LENGTH),
+      summary: normalizeSummary(summarySource),
       outgoingSlugs: page.frontmatter.edges,
     });
   }
 
-  const { listSkillEntries, SKILL_SLUG_PREFIX } =
-    await import("./skill-store.js");
-  for (const entry of listSkillEntries()) {
+  for (const entry of skillEntries) {
     drafts.push({
       slug: `${SKILL_SLUG_PREFIX}${entry.id}`,
-      summary: entry.content.trim().slice(0, SUMMARY_MAX_LENGTH),
+      summary: normalizeSummary(entry.content),
       outgoingSlugs: [],
     });
   }

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

@@ -27,7 +27,6 @@ import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 
 import { getLogger } from "../../../util/logger.js";
-import { getWorkspaceDir } from "../../../util/platform.js";
 
 const log = getLogger("memory-v2-router-prompt");
 
@@ -102,7 +101,7 @@ export function renderRouterPrompt(opts: RenderRouterPromptOpts): string {
  * 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 the workspace root.
+ * 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
@@ -111,11 +110,12 @@ export function renderRouterPrompt(opts: RenderRouterPromptOpts): string {
  */
 export function resolveRouterPrompt(
   overridePath: string | null,
+  workspaceDir: string,
   opts: RenderRouterPromptOpts,
 ): string {
   if (overridePath === null) return renderRouterPrompt(opts);
 
-  const resolvedPath = resolveOverridePath(overridePath);
+  const resolvedPath = resolveOverridePath(overridePath, workspaceDir);
   let contents: string;
   try {
     const stat = lstatSync(resolvedPath);
@@ -178,15 +178,18 @@ function substitutePlaceholders(
   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);
+    .replaceAll(ASSISTANT_NAME_PLACEHOLDER, () => assistant)
+    .replaceAll(USER_NAME_PLACEHOLDER, () => user)
+    .replaceAll(PAGE_INDEX_PLACEHOLDER, () => opts.pageIndexBlock);
 }
 
-function resolveOverridePath(overridePath: string): string {
+function resolveOverridePath(
+  overridePath: string,
+  workspaceDir: string,
+): string {
   if (overridePath.startsWith("~/")) {
     return join(homedir(), overridePath.slice(2));
   }
   if (isAbsolute(overridePath)) return overridePath;
-  return join(getWorkspaceDir(), 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

@@ -200,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 };
       }
@@ -271,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.
@@ -422,7 +470,10 @@ export async function deleteConceptPageEmbedding(slug: string): Promise<void> {
  * `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.
+ * 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.
@@ -491,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

package/src/memory/v2/router.ts

@@ -181,6 +181,7 @@ export async function runRouter(
 
   const systemPrompt = resolveRouterPrompt(
     config.memory?.v2?.router?.router_prompt_path ?? null,
+    workspaceDir,
     {
       assistantName: getAssistantName(),
       userName: resolveUserName(workspaceDir),
@@ -274,22 +275,22 @@ export async function runRouter(
     );
   }
 
-  const truncated = inRangeIds.length > maxPageIds;
-  const finalIds = truncated ? inRangeIds.slice(0, maxPageIds) : inRangeIds;
+  // De-duplicate BEFORE applying the cap — otherwise a duplicate-heavy
+  // model output like `[1, 1, 2]` with `max=2` slices to `[1, 1]` and
+  // dedupes to `[1]`, under-filling the cap.
+  const dedupedIds = Array.from(new Set(inRangeIds));
+
+  const truncated = dedupedIds.length > maxPageIds;
+  const finalIds = truncated ? dedupedIds.slice(0, maxPageIds) : dedupedIds;
   if (truncated) {
     log.warn(
-      { returned: inRangeIds.length, max: maxPageIds },
+      { returned: dedupedIds.length, max: maxPageIds },
       "Router returned more page IDs than max_page_ids; truncating",
     );
   }
 
-  // De-duplicate while preserving order — the index lookup alone wouldn't
-  // catch repeats from the model.
-  const seen = new Set<number>();
   const selectedSlugs: string[] = [];
   for (const id of finalIds) {
-    if (seen.has(id)) continue;
-    seen.add(id);
     const entry = pageIndex.byId.get(id);
     if (!entry) continue;
     selectedSlugs.push(entry.slug);

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

@@ -36,6 +36,7 @@ import {
 } from "../embedding-backend.js";
 import { invalidatePageIndex } from "./page-index.js";
 import {
+  backfillKindOnPointsWithPrefix,
   pruneSlugsWithPrefixExcept,
   upsertConceptPageEmbedding,
 } from "./qdrant.js";
@@ -78,6 +79,11 @@ export function skillSlugFor(id: string): string {
  * successful re-seed so callers always see a consistent snapshot.
  */
 let entries: Map<string, SkillEntry> | null = null;
+let requestedSeedGeneration = 0;
+let processedSeedGeneration = 0;
+let activeSeedDrain: Promise<void> | null = null;
+let lastSeedError: unknown = null;
+const seedWaiters: Array<{ generation: number; resolve: () => void }> = [];
 
 /**
  * Seed (or re-seed) skill embeddings into the unified concept-page collection.
@@ -85,32 +91,19 @@ let entries: Map<string, SkillEntry> | null = null;
  * background callers like daemon startup; pass `{ throwOnError: true }` from
  * synchronous CLI-driven paths that need to surface failures to the operator.
  *
- * Single-flight + coalesced: at most one seed runs at a time, and concurrent
- * callers are coalesced into one follow-up re-snapshot that runs after the
- * in-flight seed completes. Without this, an older snapshot can finish after
- * a newer one and overwrite the newer skill state. Strict callers observe
- * the most recent run's outcome via `lastSeedError`.
+ * Single-flight + coalesced: at most one seed runs at a time. Requests made
+ * while a seed is in flight advance the requested generation; stale in-flight
+ * snapshots are skipped before they write embeddings or replace the cache,
+ * then the drain loop immediately processes the latest generation. Strict
+ * callers observe the awaited generation's latest outcome via `lastSeedError`.
  */
-let seedTail: Promise<void> = Promise.resolve();
-let seedPending: Promise<void> | null = null;
-let lastSeedError: unknown = null;
 
-export async function seedV2SkillEntries(
-  opts: { throwOnError?: boolean } = {},
-): Promise<void> {
-  if (!seedPending) {
-    const next = seedTail.then(async () => {
-      seedPending = null;
-      await runSeedOnce();
-    });
-    seedTail = next.catch(() => {});
-    seedPending = next;
-  }
-  await seedPending;
-  if (opts.throwOnError && lastSeedError) {
-    throw lastSeedError;
-  }
-}
+/**
+ * In-process latch for the legacy `kind` backfill (see
+ * {@link backfillKindOnPointsWithPrefix}). New upserts always write `kind`,
+ * so once the latch is set there is no follow-up work to do this process.
+ */
+let legacyKindBackfillDone = false;
 
 /**
  * Steps (per run):
@@ -132,7 +125,49 @@ export async function seedV2SkillEntries(
  *      stale points from prior catalog state (e.g. uninstalled skills).
  *   7. Replace the module-level `entries` cache with the freshly built map.
  */
-async function runSeedOnce(): Promise<void> {
+export async function seedV2SkillEntries(
+  opts: { throwOnError?: boolean } = {},
+): Promise<void> {
+  const generation = ++requestedSeedGeneration;
+  const waiter = new Promise<void>((resolve) => {
+    seedWaiters.push({ generation, resolve });
+  });
+  startSeedDrainIfNeeded();
+  await waiter;
+  if (opts.throwOnError && lastSeedError) {
+    throw lastSeedError;
+  }
+}
+
+function startSeedDrainIfNeeded(): void {
+  if (activeSeedDrain) return;
+  if (processedSeedGeneration >= requestedSeedGeneration) return;
+
+  activeSeedDrain = drainSeedQueue().finally(() => {
+    activeSeedDrain = null;
+    startSeedDrainIfNeeded();
+  });
+}
+
+async function drainSeedQueue(): Promise<void> {
+  while (processedSeedGeneration < requestedSeedGeneration) {
+    const generationToProcess = requestedSeedGeneration;
+    await runSeedV2SkillEntries(generationToProcess);
+    processedSeedGeneration = generationToProcess;
+    resolveSeedWaiters();
+  }
+}
+
+function resolveSeedWaiters(): void {
+  for (let i = seedWaiters.length - 1; i >= 0; i -= 1) {
+    const waiter = seedWaiters[i]!;
+    if (waiter.generation > processedSeedGeneration) continue;
+    seedWaiters.splice(i, 1);
+    waiter.resolve();
+  }
+}
+
+async function runSeedV2SkillEntries(generation: number): Promise<void> {
   try {
     const config = getConfig();
     const catalog = loadSkillCatalog();
@@ -160,11 +195,19 @@ async function runSeedOnce(): Promise<void> {
     // Seed uninstalled catalog skills so their activation hints are
     // discoverable by intent. Track whether the catalog was available so we
     // can guard pruning below.
+    //
+    // Build the legacy-backfill allowlist in parallel: every locally
+    // installed skill id (regardless of enabled state) plus every remote
+    // catalog id. Restricting the backfill to this set keeps user-authored
+    // concept pages that happen to live under `skills/<slug>` from being
+    // mis-tagged and then pruned. See `backfillKindOnPointsWithPrefix`.
+    const knownSkillIds = new Set<string>(installedIds);
     let catalogAvailable = false;
     try {
       const fullCatalog = await getCatalog();
       catalogAvailable = fullCatalog.length > 0;
       for (const entry of fullCatalog) {
+        knownSkillIds.add(entry.id);
         if (installedIds.has(entry.id)) continue;
         const flagKey = entry.metadata?.vellum?.["feature-flag"];
         if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config))
@@ -184,12 +227,16 @@ async function runSeedOnce(): Promise<void> {
     // unavailable embedding backend in the all-disabled case, so pruning and
     // cache replacement still run and clear stale state.
     const nextEntries = new Map<string, SkillEntry>();
+    let denseVectors: number[][] = [];
+    let encodeSparse: (
+      input: string,
+    ) => ReturnType<typeof generateSparseEmbedding> = generateSparseEmbedding;
     if (seeds.length > 0) {
       const embedded = await embedWithBackend(
         config,
         seeds.map((s) => s.content),
       );
-      const denseVectors = await Promise.all(
+      denseVectors = await Promise.all(
         embedded.vectors.map((v) =>
           applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
         ),
@@ -203,14 +250,25 @@ async function runSeedOnce(): Promise<void> {
       // entirely. Fall back to the legacy TF encoder only during the cold-start
       // window before corpus stats finish building.
       const corpusStats = getConceptPageCorpusStats();
-      const encodeSparse = (input: string) =>
+      encodeSparse = (input: string) =>
         corpusStats
           ? generateBm25DocEmbedding(input, corpusStats, {
               k1: config.memory.v2.bm25_k1,
               b: config.memory.v2.bm25_b,
             })
           : generateSparseEmbedding(input);
+    }
 
+    if (generation !== requestedSeedGeneration) {
+      log.info(
+        { generation, latestGeneration: requestedSeedGeneration },
+        "Skipping stale v2 skill seed result",
+      );
+      lastSeedError = null;
+      return;
+    }
+
+    if (seeds.length > 0) {
       const now = Date.now();
       await Promise.all(
         seeds.map((seed, i) =>
@@ -233,6 +291,25 @@ async function runSeedOnce(): Promise<void> {
     // uninstalled catalog skills should exist, so skip pruning entirely to
     // avoid aggressively removing previously-seeded catalog skill embeddings.
     if (catalogAvailable) {
+      // Tag legacy skill points missing `payload.kind` before pruning so the
+      // kind-scoped prune can see them. Once-per-process; the backfill is
+      // idempotent (server-side `is_empty` filter), so a partial failure
+      // converges on retry.
+      if (!legacyKindBackfillDone) {
+        try {
+          await backfillKindOnPointsWithPrefix(
+            SKILL_SLUG_PREFIX,
+            SKILL_PAYLOAD_KIND,
+            knownSkillIds,
+          );
+          legacyKindBackfillDone = true;
+        } catch (err) {
+          log.warn(
+            { err },
+            "Failed to backfill kind on legacy skill points — pruning may leave orphans this run",
+          );
+        }
+      }
       await pruneSlugsWithPrefixExcept(
         SKILL_SLUG_PREFIX,
         seeds.map((s) => s.id),
@@ -265,12 +342,16 @@ async function runSeedOnce(): Promise<void> {
  * Accepts either a bare skill id (`example-skill`) or its unified-collection
  * slug (`skills/example-skill`) so render-side callers can pass through what
  * they have without a manual prefix strip.
+ *
+ * Returns a frozen copy so callers cannot mutate the underlying cache entry
+ * — matches the defensive-copy contract of `listSkillEntries`.
  */
 export function getSkillCapability(idOrSlug: string): SkillEntry | null {
   const id = idOrSlug.startsWith(SKILL_SLUG_PREFIX)
     ? idOrSlug.slice(SKILL_SLUG_PREFIX.length)
     : idOrSlug;
-  return entries?.get(id) ?? null;
+  const entry = entries?.get(id);
+  return entry ? Object.freeze({ ...entry }) : null;
 }
 
 /** True iff the slug refers to a skill entry in the unified collection. */
@@ -280,8 +361,9 @@ export function isSkillSlug(slug: string): boolean {
 
 /**
  * Snapshot of the in-process skill cache, sorted by skill id (ASCII order)
- * for determinism. Returns a freshly allocated array on each call so callers
- * cannot mutate the underlying cache.
+ * for determinism. Returns a freshly allocated array of frozen entry copies
+ * on each call, so callers cannot mutate the underlying cache — neither by
+ * reassigning the array nor by writing through entry fields.
  *
  * The cache is replaced atomically by `seedV2SkillEntries`, so a snapshot
  * may be stale once a subsequent seed run completes. Callers that need
@@ -289,15 +371,18 @@ export function isSkillSlug(slug: string): boolean {
  */
 export function listSkillEntries(): SkillEntry[] {
   if (!entries) return [];
-  return [...entries.values()].sort((a, b) =>
-    a.id < b.id ? -1 : a.id > b.id ? 1 : 0,
-  );
+  return [...entries.values()]
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    .map((entry) => Object.freeze({ ...entry }));
 }
 
 /** @internal Test-only: clear the module-level cache. */
 export function _resetSkillStoreForTests(): void {
   entries = null;
-  seedTail = Promise.resolve();
-  seedPending = null;
+  requestedSeedGeneration = 0;
+  processedSeedGeneration = 0;
+  activeSeedDrain = null;
+  seedWaiters.splice(0, seedWaiters.length);
   lastSeedError = null;
+  legacyKindBackfillDone = false;
 }