@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -70,16 +70,6 @@ const state = {
       points: Array<{ score?: number; payload: Record<string, unknown> }>;
     }>,
   },
-  // Separate response queue for the dedicated skills collection so a test
-  // querying both concept pages and skills doesn't have to interleave.
-  skillQueryResponses: {
-    dense: [] as Array<{
-      points: Array<{ score?: number; payload: Record<string, unknown> }>;
-    }>,
-    sparse: [] as Array<{
-      points: Array<{ score?: number; payload: Record<string, unknown> }>;
-    }>,
-  },
   queryCalls: [] as Array<{
     collection: string;
     using: string;
@@ -146,12 +136,12 @@ class MockQdrantClient {
       limit: params.limit,
       filter: params.filter,
     });
-    const channel = params.using as "dense" | "sparse";
-    const queue =
-      name === "memory_v2_skills"
-        ? state.skillQueryResponses[channel]
-        : state.queryResponses[channel];
-    return queue.shift() ?? { points: [] };
+    // Both `dense` and `summary_dense` consume from the dense queue (and
+    // similarly for sparse). The four-channel hybrid query fires them in
+    // order: body-dense, body-sparse, summary-dense, summary-sparse — so
+    // the queue order matches the call order.
+    const channel = params.using.endsWith("sparse") ? "sparse" : "dense";
+    return state.queryResponses[channel].shift() ?? { points: [] };
   }
 }
 
@@ -159,10 +149,7 @@ mock.module("@qdrant/js-client-rest", () => ({
   QdrantClient: MockQdrantClient,
 }));
 
-const { simBatch, simSkillBatch, clamp01, effectiveWeights } =
-  await import("../sim.js");
-const { _resetMemoryV2SkillQdrantForTests } =
-  await import("../skill-qdrant.js");
+const { simBatch, clamp01, effectiveWeights } = await import("../sim.js");
 const { _resetMemoryV2QdrantForTests } = await import("../qdrant.js");
 
 // ---------------------------------------------------------------------------
@@ -175,15 +162,12 @@ function resetState(): void {
   state.embedReturn = [[0.1, 0.2, 0.3]];
   state.queryResponses.dense.length = 0;
   state.queryResponses.sparse.length = 0;
-  state.skillQueryResponses.dense.length = 0;
-  state.skillQueryResponses.sparse.length = 0;
   state.queryCalls.length = 0;
   // Bun's `mock.module` persists across files in the same process, so the
-  // qdrant modules' singletons may already hold a MockQdrantClient instance
-  // from a sibling test file. Reset both readiness caches so each test in
-  // this file gets a fresh `new QdrantClient()` resolved against our mock.
+  // qdrant module's singleton may already hold a MockQdrantClient instance
+  // from a sibling test file. Reset readiness so each test in this file
+  // gets a fresh `new QdrantClient()` resolved against our mock.
   _resetMemoryV2QdrantForTests();
-  _resetMemoryV2SkillQdrantForTests();
 }
 
 function configWithWeights(
@@ -205,10 +189,18 @@ function configWithWeights(
 /**
  * Stage a single Qdrant response that maps each (slug, denseScore?, sparseScore?)
  * tuple onto the dense or sparse channel, mirroring how `hybridQueryConceptPages`
- * merges per-channel hits.
+ * merges per-channel hits. Optional `summaryDenseScore` / `summarySparseScore`
+ * stage the summary-side channels — pages without those entries fall through
+ * to body-only scoring at fusion time.
  */
 function stageHybridResponse(
-  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+  hits: Array<{
+    slug: string;
+    denseScore?: number;
+    sparseScore?: number;
+    summaryDenseScore?: number;
+    summarySparseScore?: number;
+  }>,
 ): void {
   state.queryResponses.dense.push({
     points: hits
@@ -220,6 +212,20 @@ function stageHybridResponse(
       .filter((h) => h.sparseScore !== undefined)
       .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
   });
+  // The four-channel hybrid query also fires `summary_dense` and
+  // `summary_sparse` queries against the same collection. Tests that don't
+  // care about summary scores leave those channels empty so the fallback
+  // (body-only) path runs.
+  state.queryResponses.dense.push({
+    points: hits
+      .filter((h) => h.summaryDenseScore !== undefined)
+      .map((h) => ({ score: h.summaryDenseScore, payload: { slug: h.slug } })),
+  });
+  state.queryResponses.sparse.push({
+    points: hits
+      .filter((h) => h.summarySparseScore !== undefined)
+      .map((h) => ({ score: h.summarySparseScore, payload: { slug: h.slug } })),
+  });
 }
 
 beforeEach(resetState);
@@ -488,15 +494,16 @@ describe("simBatch", () => {
     expect(out.get("loud-page")).toBe(1);
   });
 
-  test("forwards the candidate slugs as a Qdrant slug-IN filter", async () => {
+  test("forwards the candidate slugs as a Qdrant slug-IN filter on every channel", async () => {
     const config = configWithWeights(0.7, 0.3);
     stageHybridResponse([]);
 
     await simBatch("query", ["alice", "bob", "carol"], config);
 
-    // Both channels (dense + sparse) ran with the same slug-restriction
-    // filter and the same per-channel limit equal to the candidate count.
-    expect(state.queryCalls).toHaveLength(2);
+    // All four channels (body dense + sparse, summary dense + sparse) ran
+    // with the same slug-restriction filter and the same per-channel limit
+    // equal to the candidate count.
+    expect(state.queryCalls).toHaveLength(4);
     for (const call of state.queryCalls) {
       expect(call.limit).toBe(3);
       expect(call.filter).toEqual({
@@ -516,194 +523,104 @@ describe("simBatch", () => {
     expect(state.sparseCalls).toEqual(["hello world"]);
   });
 
-  test("returned scores are always in [0, 1] for arbitrary inputs", async () => {
-    const config = configWithWeights(0.7, 0.3);
+  test("takes max(body, summary) per slug — summary higher than body wins", async () => {
+    // Body channels return a modest score; summary channels return a much
+    // higher score. The max collapses to the summary score.
+    const config = configWithWeights(1.0, 0.0);
     stageHybridResponse([
-      { slug: "a", denseScore: 0.99, sparseScore: 100 },
-      { slug: "b", denseScore: 0.5, sparseScore: 50 },
-      { slug: "c", denseScore: 0.0, sparseScore: 1 },
-      { slug: "d", denseScore: 0.123, sparseScore: 0 }, // explicit zero
+      {
+        slug: "alice",
+        denseScore: 0.3,
+        summaryDenseScore: 0.7,
+      },
     ]);
 
-    const out = await simBatch("query", ["a", "b", "c", "d"], config);
-
-    for (const [, score] of out) {
-      expect(score).toBeGreaterThanOrEqual(0);
-      expect(score).toBeLessThanOrEqual(1);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// simSkillBatch
-// ---------------------------------------------------------------------------
+    const out = await simBatch("query", ["alice"], config);
 
-/**
- * Stage a single hybrid response on the dedicated skills queues. Mirrors
- * `stageHybridResponse` but uses `payload.id` (skills' Qdrant payload key)
- * instead of `payload.slug`.
- */
-function stageSkillHybridResponse(
-  hits: Array<{ id: string; denseScore?: number; sparseScore?: number }>,
-): void {
-  state.skillQueryResponses.dense.push({
-    points: hits
-      .filter((h) => h.denseScore !== undefined)
-      .map((h) => ({ score: h.denseScore, payload: { id: h.id } })),
+    expect(out.get("alice")).toBeCloseTo(0.7, 6);
   });
-  state.skillQueryResponses.sparse.push({
-    points: hits
-      .filter((h) => h.sparseScore !== undefined)
-      .map((h) => ({ score: h.sparseScore, payload: { id: h.id } })),
-  });
-}
-
-describe("simSkillBatch", () => {
-  test("empty id list returns empty map without touching backends", async () => {
-    const config = configWithWeights(0.7, 0.3);
-
-    const out = await simSkillBatch("anything", [], config);
 
-    expect(out.size).toBe(0);
-    expect(state.embedCalls).toHaveLength(0);
-    expect(state.sparseCalls).toHaveLength(0);
-    expect(state.queryCalls).toHaveLength(0);
-  });
-
-  test("empty text returns empty map without touching backends", async () => {
-    const config = configWithWeights(0.7, 0.3);
-
-    for (const text of ["", "   ", "\n\n"]) {
-      state.embedCalls.length = 0;
-      state.sparseCalls.length = 0;
-      state.queryCalls.length = 0;
-      const out = await simSkillBatch(text, ["example-skill-a"], config);
-      expect(out.size).toBe(0);
-      expect(state.embedCalls).toHaveLength(0);
-      expect(state.sparseCalls).toHaveLength(0);
-      expect(state.queryCalls).toHaveLength(0);
-    }
-  });
-
-  test("queries the dedicated skills collection and forwards an id-IN filter", async () => {
-    const config = configWithWeights(0.7, 0.3);
-    stageSkillHybridResponse([]);
+  test("takes max(body, summary) per slug — body higher than summary wins", async () => {
+    // Inverse case: body dominates, max stays at body.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.9,
+        summaryDenseScore: 0.4,
+      },
+    ]);
 
-    await simSkillBatch(
-      "query",
-      ["example-skill-a", "example-skill-b"],
-      config,
-    );
+    const out = await simBatch("query", ["alice"], config);
 
-    expect(state.queryCalls).toHaveLength(2);
-    for (const call of state.queryCalls) {
-      expect(call.collection).toBe("memory_v2_skills");
-      // The candidate ids are forwarded as a Qdrant filter so Qdrant scores
-      // exactly the candidate set, not its global top-K. Without this,
-      // candidate ids absent from the global top-K silently score 0.
-      expect(call.filter).toEqual({
-        must: [
-          { key: "id", match: { any: ["example-skill-a", "example-skill-b"] } },
-        ],
-      });
-      // Limit equals the candidate count.
-      expect(call.limit).toBe(2);
-    }
+    expect(out.get("alice")).toBeCloseTo(0.9, 6);
   });
 
-  test("fuses dense + sparse with the configured weight blend", async () => {
-    const config = configWithWeights(0.4, 0.6);
-    stageSkillHybridResponse([
-      { id: "example-skill-a", denseScore: 0.5, sparseScore: 4 }, // sparse-norm 1.0
-      { id: "example-skill-b", denseScore: 0.25, sparseScore: 2 }, // sparse-norm 0.5
+  test("falls back to body-only when the page has no summary embedding", async () => {
+    // Pages predating the summary field have no summary_dense/sparse vectors.
+    // Their summary channels return no hits — the max collapses to body.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "legacy-page",
+        denseScore: 0.6,
+        // summaryDenseScore / summarySparseScore omitted
+      },
     ]);
 
-    const out = await simSkillBatch(
-      "query",
-      ["example-skill-a", "example-skill-b"],
-      config,
-    );
+    const out = await simBatch("query", ["legacy-page"], config);
 
-    // example-skill-a: 0.4 * 0.5 + 0.6 * 1.0 = 0.8
-    // example-skill-b: 0.4 * 0.25 + 0.6 * 0.5 = 0.4
-    expect(out.get("example-skill-a")).toBeCloseTo(0.8, 6);
-    expect(out.get("example-skill-b")).toBeCloseTo(0.4, 6);
+    expect(out.get("legacy-page")).toBeCloseTo(0.6, 6);
   });
 
-  test("dense-only and sparse-only hits are handled symmetrically", async () => {
-    const config = configWithWeights(0.7, 0.3);
-    stageSkillHybridResponse([
-      { id: "example-skill-a", denseScore: 0.5 /* sparse omitted */ },
-      { id: "example-skill-b", sparseScore: 8 /* dense omitted */ },
+  test("normalizes body and summary sparse channels independently", async () => {
+    // Summary sparse scores live on a different scale than body sparse —
+    // a small absolute summary-sparse value (1.5) on the only page that
+    // has summary signal still normalizes to 1.0 within the summary
+    // channel, so the summary-only fused score should win out.
+    const config = configWithWeights(0.0, 1.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.0,
+        sparseScore: 100, // body sparse max in this batch
+      },
+      {
+        slug: "bob",
+        denseScore: 0.0,
+        sparseScore: 0.5, // body sparse normalized = 0.005
+        summaryDenseScore: 0.0,
+        summarySparseScore: 1.5, // summary sparse max in this batch
+      },
     ]);
 
-    const out = await simSkillBatch(
-      "query",
-      ["example-skill-a", "example-skill-b"],
-      config,
-    );
+    const out = await simBatch("query", ["alice", "bob"], config);
 
-    // example-skill-a: 0.7 * 0.5 + 0.3 * 0   = 0.35
-    // example-skill-b: 0.7 * 0   + 0.3 * 1.0 = 0.30 (sparse-norm = 8/8)
-    expect(out.get("example-skill-a")).toBeCloseTo(0.35, 6);
-    expect(out.get("example-skill-b")).toBeCloseTo(0.3, 6);
+    // Alice has only body. Body sparse normalized to 1.0; sparse_weight=1.0 → 1.0.
+    expect(out.get("alice")).toBeCloseTo(1.0, 6);
+    // Bob's summary side normalizes its 1.5 (only sparse-bearing summary
+    // hit) — a single sparse-bearing hit is below the adaptive-spread
+    // floor, so the channel collapses to base weights and the lone
+    // sparseNormalized=1.0 hit yields a fused summary score of 1.0.
+    // Body side has only bob's tiny sparse=0.5 against the body batch max
+    // of 100 → ~0.005. The max picks the summary side.
+    expect(out.get("bob")).toBeCloseTo(1.0, 6);
   });
 
-  test("forwards candidate ids as the Qdrant restriction; only candidates in result", async () => {
-    // The bug we're guarding against: when the skills collection has more
-    // skills than `ids.length`, calling `hybridQuerySkills` without a filter
-    // returns Qdrant's global top-K. Candidate ids absent from that top-K
-    // would silently score 0. The fix is to forward the candidate ids as a
-    // server-side restriction so Qdrant scores exactly the candidate set.
+  test("returned scores are always in [0, 1] for arbitrary inputs", async () => {
     const config = configWithWeights(0.7, 0.3);
-    stageSkillHybridResponse([
-      { id: "example-skill-a", denseScore: 0.5, sparseScore: 1 },
-      // `example-skill-c` would never be returned in production once the
-      // filter is applied; the post-filter in simSkillBatch defensively
-      // drops it even if a stale payload slips through.
-      { id: "example-skill-c", denseScore: 0.9, sparseScore: 1 },
+    stageHybridResponse([
+      { slug: "a", denseScore: 0.99, sparseScore: 100 },
+      { slug: "b", denseScore: 0.5, sparseScore: 50 },
+      { slug: "c", denseScore: 0.0, sparseScore: 1 },
+      { slug: "d", denseScore: 0.123, sparseScore: 0 }, // explicit zero
     ]);
 
-    const out = await simSkillBatch(
-      "query",
-      ["example-skill-a", "example-skill-b"],
-      config,
-    );
+    const out = await simBatch("query", ["a", "b", "c", "d"], config);
 
-    // The Qdrant filter was forwarded — both channels carry the id-IN
-    // restriction matching the caller's candidate set.
-    expect(state.queryCalls).toHaveLength(2);
-    for (const call of state.queryCalls) {
-      expect(call.filter).toEqual({
-        must: [
-          { key: "id", match: { any: ["example-skill-a", "example-skill-b"] } },
-        ],
-      });
+    for (const [, score] of out) {
+      expect(score).toBeGreaterThanOrEqual(0);
+      expect(score).toBeLessThanOrEqual(1);
     }
-    // Only candidate ids appear in the result map.
-    expect(out.has("example-skill-a")).toBe(true);
-    expect(out.has("example-skill-c")).toBe(false);
-  });
-
-  test("returned scores are clamped into [0, 1]", async () => {
-    const config = configWithWeights(0.8, 0.5); // intentionally sums to > 1
-    stageSkillHybridResponse([
-      { id: "example-skill-a", denseScore: 1.0, sparseScore: 1 },
-    ]);
-
-    const out = await simSkillBatch("query", ["example-skill-a"], config);
-
-    expect(out.get("example-skill-a")).toBe(1);
-  });
-
-  test("embeds the query text exactly once via dense + sparse backends", async () => {
-    const config = configWithWeights(0.7, 0.3);
-    stageSkillHybridResponse([]);
-
-    await simSkillBatch("hello skill", ["example-skill-a"], config);
-
-    expect(state.embedCalls).toHaveLength(1);
-    expect(state.embedCalls[0].inputs).toEqual(["hello skill"]);
-    expect(state.sparseCalls).toEqual(["hello skill"]);
   });
 });

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

@@ -1,12 +1,17 @@
 /**
  * Tests for `assistant/src/memory/v2/skill-store.ts`.
  *
- * Coverage matrix from PR 5 acceptance criteria:
+ * Coverage matrix:
  *   - `seedV2SkillEntries` enumerates the catalog and calls
- *     `upsertSkillEmbedding` for each enabled skill.
+ *     `upsertConceptPageEmbedding` with `slug: "skills/<id>"` for each
+ *     enabled skill in the unified `memory_v2_concept_pages` collection.
  *   - It skips skills whose declared feature flag is disabled.
- *   - It calls `pruneSkillsExcept` with the active id list.
- *   - It populates the `entries` cache so `getSkillCapability` returns each entry.
+ *   - It calls `pruneSlugsWithPrefixExcept("skills/", ...)` with the active
+ *     id list as suffixes, so stale skill slugs in the unified collection
+ *     get pruned without touching concept-page slugs.
+ *   - It populates the `entries` cache so `getSkillCapability` returns each
+ *     entry — accepting both bare ids (`"example-skill"`) and unified-collection
+ *     slugs (`"skills/example-skill"`).
  *   - It swallows errors from the embedding backend — the function resolves
  *     and the cache is unchanged from prior state.
  *
@@ -29,6 +34,18 @@ mock.module("../../../util/logger.js", () => ({
 // Programmable test state — drives every mocked dependency below.
 // ---------------------------------------------------------------------------
 
+interface UpsertCall {
+  slug: string;
+  dense: number[];
+  sparse: { indices: number[]; values: number[] };
+  updatedAt: number;
+}
+
+interface PruneCall {
+  prefix: string;
+  activeSuffixes: readonly string[];
+}
+
 interface TestState {
   catalog: SkillSummary[];
   resolved: ResolvedSkill[];
@@ -38,14 +55,8 @@ interface TestState {
   embedThrows: Error | null;
   embedReturn: number[][];
   sparseReturn: { indices: number[]; values: number[] };
-  upsertCalls: Array<{
-    id: string;
-    content: string;
-    dense: number[];
-    sparse: { indices: number[]; values: number[] };
-    updatedAt: number;
-  }>;
-  pruneCalls: Array<readonly string[]>;
+  upsertCalls: UpsertCall[];
+  pruneCalls: PruneCall[];
   upsertThrows: Error | null;
 }
 
@@ -99,13 +110,16 @@ mock.module("../../embedding-backend.js", () => ({
   generateSparseEmbedding: () => state.sparseReturn,
 }));
 
-mock.module("../skill-qdrant.js", () => ({
-  upsertSkillEmbedding: async (params: TestState["upsertCalls"][number]) => {
+mock.module("../qdrant.js", () => ({
+  upsertConceptPageEmbedding: async (params: UpsertCall) => {
     if (state.upsertThrows) throw state.upsertThrows;
     state.upsertCalls.push(params);
   },
-  pruneSkillsExcept: async (ids: readonly string[]) => {
-    state.pruneCalls.push(ids);
+  pruneSlugsWithPrefixExcept: async (
+    prefix: string,
+    activeSuffixes: readonly string[],
+  ) => {
+    state.pruneCalls.push({ prefix, activeSuffixes });
   },
 }));
 
@@ -160,7 +174,7 @@ afterEach(resetState);
 // ---------------------------------------------------------------------------
 
 describe("seedV2SkillEntries", () => {
-  test("enumerates the catalog and upserts one point per enabled skill", async () => {
+  test("upserts each enabled skill into the unified collection under skills/<id>", async () => {
     const skillA = makeSummary({
       id: "example-skill-a",
       displayName: "Skill A",
@@ -182,15 +196,16 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.upsertCalls).toHaveLength(2);
-    const ids = state.upsertCalls.map((c) => c.id).sort();
-    expect(ids).toEqual(["example-skill-a", "example-skill-b"]);
-
-    // Each upsert carries the per-skill dense + sparse + content payload.
-    const callA = state.upsertCalls.find((c) => c.id === "example-skill-a")!;
+    const slugs = state.upsertCalls.map((c) => c.slug).sort();
+    expect(slugs).toEqual(["skills/example-skill-a", "skills/example-skill-b"]);
+
+    // Each upsert carries the per-skill dense + sparse + updatedAt payload,
+    // keyed under the unified `skills/<id>` slug.
+    const callA = state.upsertCalls.find(
+      (c) => c.slug === "skills/example-skill-a",
+    )!;
     expect(callA.dense).toEqual([0.1, 0.2, 0.3]);
     expect(callA.sparse).toEqual(state.sparseReturn);
-    expect(callA.content).toContain("Skill A");
-    expect(callA.content).toContain("(example-skill-a)");
     expect(callA.updatedAt).toBeGreaterThan(0);
   });
 
@@ -207,12 +222,11 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.upsertCalls).toHaveLength(1);
-    expect(state.upsertCalls[0].id).toBe("example-skill-a");
+    expect(state.upsertCalls[0].slug).toBe("skills/example-skill-a");
   });
 
   test("does not re-seed an installed-but-disabled skill from the remote catalog", async () => {
-    // Regression for https://github.com/vellum-ai/vellum-assistant/pull/28635
-    // (Codex P1): if `seenIds` is built only from enabled skills, a locally
+    // Regression: if `seenIds` is built only from enabled skills, a locally
     // installed-but-disabled skill falls through to the catalog loop and gets
     // embedded as if it were a discoverable uninstalled skill — contradicting
     // the user's explicit disablement.
@@ -223,8 +237,6 @@ describe("seedV2SkillEntries", () => {
       { summary: enabledSkill, state: "enabled" },
       { summary: disabledSkill, state: "disabled" },
     ];
-    // The remote catalog also contains the disabled skill (same id) — the
-    // seed function must NOT pull it back in via `getCatalog()`.
     state.fullCatalog = [
       {
         id: "example-skill-b",
@@ -237,7 +249,7 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.upsertCalls).toHaveLength(1);
-    expect(state.upsertCalls[0].id).toBe("example-skill-a");
+    expect(state.upsertCalls[0].slug).toBe("skills/example-skill-a");
   });
 
   test("seeds genuinely uninstalled catalog skills alongside enabled installed skills", async () => {
@@ -263,8 +275,11 @@ describe("seedV2SkillEntries", () => {
 
     await seedV2SkillEntries();
 
-    const ids = state.upsertCalls.map((c) => c.id).sort();
-    expect(ids).toEqual(["example-skill-a", "uninstalled-skill"]);
+    const slugs = state.upsertCalls.map((c) => c.slug).sort();
+    expect(slugs).toEqual([
+      "skills/example-skill-a",
+      "skills/uninstalled-skill",
+    ]);
   });
 
   test("skips skills whose declared feature flag is disabled", async () => {
@@ -284,10 +299,10 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.upsertCalls).toHaveLength(1);
-    expect(state.upsertCalls[0].id).toBe("example-skill-b");
+    expect(state.upsertCalls[0].slug).toBe("skills/example-skill-b");
   });
 
-  test("calls pruneSkillsExcept with the active id list", async () => {
+  test("calls pruneSlugsWithPrefixExcept with the active id list and the skills/ prefix", async () => {
     const skillA = makeSummary({ id: "example-skill-a" });
     const skillB = makeSummary({ id: "example-skill-b" });
     state.catalog = [skillA, skillB];
@@ -309,13 +324,14 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.pruneCalls).toHaveLength(1);
-    expect([...state.pruneCalls[0]].sort()).toEqual([
+    expect(state.pruneCalls[0].prefix).toBe("skills/");
+    expect([...state.pruneCalls[0].activeSuffixes].sort()).toEqual([
       "example-skill-a",
       "example-skill-b",
     ]);
   });
 
-  test("passes only the active (post-flag-filter) ids to pruneSkillsExcept", async () => {
+  test("passes only the active (post-flag-filter) ids to pruneSlugsWithPrefixExcept", async () => {
     const flagged = makeSummary({
       id: "example-skill-a",
       featureFlag: "off-flag",
@@ -327,8 +343,6 @@ describe("seedV2SkillEntries", () => {
       { summary: unflagged, state: "enabled" },
     ];
     state.flagsEnabled = { "off-flag": false };
-    // Remote catalog must be non-empty so catalogAvailable is true and
-    // pruning is not skipped.
     state.fullCatalog = [
       { id: "example-skill-a", name: "example-skill-a", description: "A" },
       { id: "example-skill-b", name: "example-skill-b", description: "B" },
@@ -338,44 +352,35 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.pruneCalls).toHaveLength(1);
-    expect([...state.pruneCalls[0]]).toEqual(["example-skill-b"]);
+    expect(state.pruneCalls[0].prefix).toBe("skills/");
+    expect([...state.pruneCalls[0].activeSuffixes]).toEqual([
+      "example-skill-b",
+    ]);
   });
 
-  test("populates the entries cache so getSkillCapability returns each entry", async () => {
+  test("populates the entries cache so getSkillCapability resolves both bare id and unified slug", async () => {
     const skillA = makeSummary({
       id: "example-skill-a",
       displayName: "Skill A",
     });
-    const skillB = makeSummary({
-      id: "example-skill-b",
-      displayName: "Skill B",
-    });
-    state.catalog = [skillA, skillB];
-    state.resolved = [
-      { summary: skillA, state: "enabled" },
-      { summary: skillB, state: "enabled" },
-    ];
-    state.embedReturn = [
-      [0.1, 0.2, 0.3],
-      [0.4, 0.5, 0.6],
-    ];
+    state.catalog = [skillA];
+    state.resolved = [{ summary: skillA, state: "enabled" }];
+    state.embedReturn = [[0.1, 0.2, 0.3]];
 
     expect(getSkillCapability("example-skill-a")).toBeNull();
 
     await seedV2SkillEntries();
 
-    const entryA = getSkillCapability("example-skill-a");
-    const entryB = getSkillCapability("example-skill-b");
-    expect(entryA).not.toBeNull();
-    expect(entryA?.id).toBe("example-skill-a");
-    expect(entryA?.content).toContain("Skill A");
-
-    expect(entryB).not.toBeNull();
-    expect(entryB?.id).toBe("example-skill-b");
-    expect(entryB?.content).toContain("Skill B");
+    // Bare id and unified-slug forms both resolve to the same entry.
+    const byId = getSkillCapability("example-skill-a");
+    const bySlug = getSkillCapability("skills/example-skill-a");
+    expect(byId).not.toBeNull();
+    expect(byId?.id).toBe("example-skill-a");
+    expect(byId?.content).toContain("Skill A");
+    expect(bySlug).toEqual(byId);
 
-    // Unknown ids return null even when the cache is populated.
     expect(getSkillCapability("unknown-skill")).toBeNull();
+    expect(getSkillCapability("skills/unknown-skill")).toBeNull();
   });
 
   test("swallows errors from embedWithBackend and leaves prior cache intact", async () => {
@@ -426,9 +431,10 @@ describe("seedV2SkillEntries", () => {
     await seedV2SkillEntries();
 
     expect(state.upsertCalls).toHaveLength(1);
-    expect(state.upsertCalls[0].id).toBe("remote-only");
+    expect(state.upsertCalls[0].slug).toBe("skills/remote-only");
     expect(state.pruneCalls).toHaveLength(1);
-    expect([...state.pruneCalls[0]]).toEqual(["remote-only"]);
+    expect(state.pruneCalls[0].prefix).toBe("skills/");
+    expect([...state.pruneCalls[0].activeSuffixes]).toEqual(["remote-only"]);
   });
 
   test("skips pruning when catalog fetch returns empty (network failure guard)", async () => {