@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -8,18 +8,18 @@
  *   - A new topic appearing on a later turn injects only the new slug.
  *   - `evictCompactedTurns` re-enables a previously-injected slug —
  *     after eviction the same slug appears again in `toInject`.
- *   - Skill pipeline: skill-only block, mixed concept-page+skill block,
- *     both-empty → null, no skill dedup across turns, `top_k_skills: 0`
- *     short-circuit.
+ *   - Unified-pool skills: a `skills/<id>` slug ranked into the top-K is
+ *     rendered under `### Skills You Can Use`, mixed concept-page+skill
+ *     blocks render concept sections first then the skills suffix, both
+ *     empty → null block, skills participate in `everInjected` so they
+ *     deduplicate across turns just like concepts.
  *
  * Hermetic by design: the embedding backend, qdrant client, and `getConfig`
  * are mocked at the module level so the suite never reaches a real backend.
- * The skill activation pipeline (`computeSkillActivation`,
- * `selectSkillInjections`) and the skill-store helpers (`getAllSkillIds`,
- * `getSkillCapability`) are also mocked at the module level so each test can
- * stage its skill slate without touching the dedicated skills Qdrant
- * collection. The activation-store uses an in-memory SQLite database so
- * writes are real but contained.
+ * The skill-store cache (`getSkillCapability`, `isSkillSlug`) is mocked so
+ * each test can stage skill content without touching the real catalog.
+ * The activation-store uses an in-memory SQLite database so writes are
+ * real but contained.
  *
  * Tests use a temp workspace (mkdtemp) and never touch `~/.vellum/`. Sample
  * page content uses generic placeholders (Alice, Bob, etc.) per the cross-
@@ -114,8 +114,11 @@ class MockQdrantClient {
     _name: string,
     params: { using: string; limit: number; filter?: unknown },
   ) {
-    const queue = state.queryResponses[params.using as "dense" | "sparse"];
-    return queue.shift() ?? { points: [] };
+    // The four-channel hybrid query fires body-dense, body-sparse,
+    // summary-dense, summary-sparse in order; both dense channels share
+    // the dense queue and both sparse channels share the sparse queue.
+    const channel = params.using.endsWith("sparse") ? "sparse" : "dense";
+    return state.queryResponses[channel].shift() ?? { points: [] };
   }
 }
 
@@ -124,44 +127,32 @@ mock.module("@qdrant/js-client-rest", () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Skill pipeline mocks
+// Skill-store mock
 // ---------------------------------------------------------------------------
 //
-// The skill side of the per-turn pipeline (`computeSkillActivation`,
-// `selectSkillInjections`) has its own dedicated Qdrant collection and
-// embedding round-trips. Rather than threading staged hits through that whole
-// pipeline for every test, we mock the two activation helpers and the two
-// skill-store helpers (`getAllSkillIds` for the candidate pool,
-// `getSkillCapability` for content lookup) at the module level and let each
-// test stage a `topNow` ordering and the matching `SkillEntry` content
-// directly.
+// Skills now flow through the unified pipeline under the `skills/<id>` slug
+// prefix — they are scored by `simBatch` against the same Qdrant collection
+// as concept pages, ranked by `selectInjections`, and rendered alongside
+// concept sections. The render path branches on `isSkillSlug(slug)` to fetch
+// content from the in-process cache via `getSkillCapability` instead of
+// reading a page from disk. Tests stage that cache and rely on the regular
+// `stageTurn` plumbing to land skill slugs in the candidate set.
 
 const skillState = {
-  /** Ordered ids `selectSkillInjections.topNow` returns this turn. */
-  topSkillIds: [] as string[],
-  /** id → SkillEntry used by `getSkillCapability` and `getAllSkillIds`. */
+  /** id → SkillEntry consulted by `getSkillCapability`. */
   entries: new Map<string, SkillEntry>(),
 };
 
-const realActivation = await import("../activation.js");
-mock.module("../activation.js", () => ({
-  ...realActivation,
-  // The injection wiring only consumes `topNow` — the candidate set and
-  // activation map are inputs to `selectSkillInjections`, not anything the
-  // injection logic introspects. Stub them to empty so the test stays focused
-  // on the wiring, not the pipeline internals (covered in activation.test.ts).
-  computeSkillActivation: async () => ({
-    activation: new Map<string, number>(),
-    breakdown: new Map(),
-  }),
-  selectSkillInjections: ({ topK }: { topK: number }) => ({
-    topNow: skillState.topSkillIds.slice(0, topK),
-  }),
-}));
-
 mock.module("../skill-store.js", () => ({
-  getAllSkillIds: () => [...skillState.entries.keys()],
-  getSkillCapability: (id: string) => skillState.entries.get(id) ?? null,
+  getSkillCapability: (idOrSlug: string) => {
+    const id = idOrSlug.startsWith("skills/")
+      ? idOrSlug.slice("skills/".length)
+      : idOrSlug;
+    return skillState.entries.get(id) ?? null;
+  },
+  isSkillSlug: (slug: string) => slug.startsWith("skills/"),
+  SKILL_SLUG_PREFIX: "skills/",
+  skillSlugFor: (id: string) => `skills/${id}`,
 }));
 
 // ---------------------------------------------------------------------------
@@ -241,6 +232,18 @@ ref_files:
 ---
 Demo body content.`,
   );
+  // A page WITH a `summary` in its frontmatter — exercises the summary-only
+  // injection path. Body is intentionally longer than the summary so tests
+  // can assert that the body is *not* injected when the summary is present.
+  writeFileSync(
+    join(tmpWorkspace, "memory", "concepts", "summarized-page.md"),
+    `---
+edges: []
+ref_files: []
+summary: A short prose description of the summarized page that retrieval injects in place of the full body.
+---
+Long-form body content that should NOT appear in the injection block when the page has a summary in frontmatter — the agent reads the file on demand instead.`,
+  );
 });
 
 afterAll(() => {
@@ -293,7 +296,6 @@ function makeConfig(
     k: number;
     hops: number;
     top_k: number;
-    top_k_skills: number;
     epsilon: number;
     dense_weight: number;
     sparse_weight: number;
@@ -308,8 +310,7 @@ function makeConfig(
         c_now: 0.2,
         k: 0.5,
         hops: 2,
-        top_k: 20,
-        top_k_skills: 5,
+        top_k: 25,
         epsilon: 0.01,
         dense_weight: 1.0,
         sparse_weight: 0.0,
@@ -322,14 +323,26 @@ function makeConfig(
 /**
  * Stage one set of dense/sparse hits, used uniformly by every `simBatch`
  * channel call (user/assistant/now) AND by the un-restricted ANN candidate
- * query. The candidate query runs first, then three simBatch calls, so we
- * push 4 dense + 4 sparse responses per turn.
+ * query. The candidate query runs first, then three simBatch calls — that's
+ * `channels` (= 4) logical hybrid queries. Each logical hybrid query now
+ * fires a four-channel fan-out (body dense, body sparse, summary dense,
+ * summary sparse), so we push 2 dense + 2 sparse responses per logical
+ * call to match the post-summary-vector wire pattern.
  *
  * Each entry is mapped to a hit per channel; pass `denseScore`/`sparseScore`
- * undefined to omit a slug from that channel.
+ * undefined to omit a slug from that channel. `summaryDenseScore` /
+ * `summarySparseScore` route to the summary-side channels — tests that
+ * don't care about summary scoring leave them undefined and the summary
+ * channel falls back to body-only behavior.
  */
 function stageTurn(
-  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+  hits: Array<{
+    slug: string;
+    denseScore?: number;
+    sparseScore?: number;
+    summaryDenseScore?: number;
+    summarySparseScore?: number;
+  }>,
   channels = 4,
 ): void {
   // Clear any leftovers from a prior turn before staging this one so unused
@@ -350,6 +363,22 @@ function stageTurn(
         .filter((h) => h.sparseScore !== undefined)
         .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
     });
+    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 },
+        })),
+    });
   }
 }
 
@@ -358,7 +387,6 @@ function resetState(): void {
   state.sparseReturn = { indices: [1, 2, 3], values: [0.5, 0.5, 0.5] };
   state.queryResponses.dense.length = 0;
   state.queryResponses.sparse.length = 0;
-  skillState.topSkillIds.length = 0;
   skillState.entries.clear();
   telemetryState.recordCalls.length = 0;
   telemetryState.recordShouldThrow = false;
@@ -368,10 +396,8 @@ function resetState(): void {
   _resetMemoryV2QdrantForTests();
 }
 
-/** Stage the next turn's skill slate and the entries the renderer will look up. */
-function stageSkills(ids: string[], entries: SkillEntry[] = []): void {
-  skillState.topSkillIds.length = 0;
-  skillState.topSkillIds.push(...ids);
+/** Stage skill-store cache entries for the upcoming render. */
+function stageSkills(entries: SkillEntry[]): void {
   for (const entry of entries) {
     skillState.entries.set(entry.id, entry);
   }
@@ -412,7 +438,7 @@ describe("injectMemoryV2Block", () => {
     expect(result.block).not.toContain("<memory>");
     expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
-    expect(result.block).toContain("### alice-vscode");
+    expect(result.block).toContain("# memory/concepts/alice-vscode.md");
     expect(result.block).toContain("VS Code");
 
     // State persisted: alice's activation is above epsilon and recorded;
@@ -501,10 +527,10 @@ describe("injectMemoryV2Block", () => {
     });
 
     expect(result.toInject).toEqual(["carol-jazz"]);
-    expect(result.block).toContain("### carol-jazz");
+    expect(result.block).toContain("# memory/concepts/carol-jazz.md");
     // The block only shows the new slug — alice's attachment lives on the
     // previous turn's user message.
-    expect(result.block).not.toContain("### alice-vscode");
+    expect(result.block).not.toContain("# memory/concepts/alice-vscode.md");
 
     const persisted = await hydrate(db, "conv-1");
     expect(persisted!.everInjected).toEqual([
@@ -549,7 +575,7 @@ describe("injectMemoryV2Block", () => {
     });
 
     expect(result.toInject).toEqual(["alice-vscode"]);
-    expect(result.block).toContain("### alice-vscode");
+    expect(result.block).toContain("# memory/concepts/alice-vscode.md");
 
     const persisted = await hydrate(db, "conv-1");
     expect(persisted!.everInjected).toEqual([
@@ -557,6 +583,74 @@ describe("injectMemoryV2Block", () => {
     ]);
   });
 
+  test("page with summary renders as path + summary, no body, with the CRITICAL header", async () => {
+    // Pages whose frontmatter carries a `summary` should inject only the
+    // summary text behind the path header — the agent reads the full file
+    // on demand. The leading `**CRITICAL:**` line tells the agent how to
+    // read the block.
+    stageTurn([{ slug: "summarized-page", denseScore: 0.9 }]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "tell me about the summarized page",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(result.block).not.toBeNull();
+    expect(result.block).toContain(
+      "**CRITICAL:** These are page summaries. Read the page file if it looks relevant.",
+    );
+    expect(result.block).toContain(
+      "# memory/concepts/summarized-page.md\nA short prose description",
+    );
+    // Body is NOT in the block — the agent must follow up with a read tool.
+    expect(result.block).not.toContain("Long-form body content");
+    // Frontmatter is also omitted; the path header carries the identifying
+    // information by itself, and edges flow through the activation graph.
+    expect(result.block).not.toContain("---\nedges:");
+  });
+
+  test("mixed batch — summary page renders short, fallback page renders full", async () => {
+    // Both pages rank into top-K. summarized-page has a summary → short
+    // form. frontmatter-demo has no summary → full-page fallback. The
+    // single CRITICAL header sits at the top regardless.
+    stageTurn([
+      { slug: "summarized-page", denseScore: 0.95 },
+      { slug: "frontmatter-demo", denseScore: 0.85 },
+    ]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "show me everything",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(result.block).not.toBeNull();
+    // CRITICAL header appears exactly once.
+    const criticalCount = (
+      result.block!.match(/\*\*CRITICAL:\*\* These are page summaries\./g) ?? []
+    ).length;
+    expect(criticalCount).toBe(1);
+    // summarized-page → short form (path + summary, no body, no frontmatter).
+    expect(result.block).toContain("# memory/concepts/summarized-page.md\nA");
+    expect(result.block).not.toContain("Long-form body content");
+    // frontmatter-demo → full-page fallback (path + frontmatter + body).
+    expect(result.block).toContain(
+      "# memory/concepts/frontmatter-demo.md\n---\n",
+    );
+    expect(result.block).toContain("Demo body content.");
+  });
+
   test("includes the page frontmatter (edges, ref_files) in each rendered section", async () => {
     // The frontmatter (`edges`, `ref_files`) lives on disk above the page
     // body and is part of the page's content. Injection must reproduce both
@@ -577,8 +671,12 @@ describe("injectMemoryV2Block", () => {
     });
 
     expect(result.block).not.toBeNull();
-    // Slug header is immediately followed by the frontmatter open delimiter.
-    expect(result.block).toContain("### frontmatter-demo\n---\n");
+    // Path header is immediately followed by the frontmatter open delimiter.
+    // The fallback path renders the full page (frontmatter + body) when the
+    // page has no `summary` field — `frontmatter-demo` predates the field.
+    expect(result.block).toContain(
+      "# memory/concepts/frontmatter-demo.md\n---\n",
+    );
     // Both fields render in YAML block style with their populated values.
     expect(result.block).toContain("edges:\n  - alice-vscode");
     expect(result.block).toContain("ref_files:\n  - images/demo.jpg");
@@ -606,8 +704,8 @@ describe("injectMemoryV2Block", () => {
     });
 
     expect(result.toInject).toEqual(["carol-jazz", "alice-vscode"]);
-    const carolIdx = result.block!.indexOf("### carol-jazz");
-    const aliceIdx = result.block!.indexOf("### alice-vscode");
+    const carolIdx = result.block!.indexOf("# memory/concepts/carol-jazz.md");
+    const aliceIdx = result.block!.indexOf("# memory/concepts/alice-vscode.md");
     expect(carolIdx).toBeGreaterThan(-1);
     expect(aliceIdx).toBeGreaterThan(-1);
     expect(carolIdx).toBeLessThan(aliceIdx);
@@ -676,24 +774,22 @@ describe("injectMemoryV2Block", () => {
   });
 
   // ---------------------------------------------------------------------------
-  // Skill subsection rendering
+  // Unified pool — skills as `skills/<id>` slugs
   // ---------------------------------------------------------------------------
 
-  test("renders a skill-only block alongside concept-page-only blocks", async () => {
-    // No concept-page candidates this turn — the candidate query and the three
-    // simBatch queries all return empty. The skill pipeline is mocked to
-    // surface a single skill.
-    stageTurn([]);
-    stageSkills(
-      ["example-skill-a"],
-      [
-        {
-          id: "example-skill-a",
-          content:
-            'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
-        },
-      ],
-    );
+  test("renders a skill-only block via the skills/ slug prefix", async () => {
+    // No concept-page candidates this turn — the only ANN hit is a skill
+    // slug. The render path branches on `skills/` prefix: it pulls the
+    // entry from the skill-store cache (mocked) and emits the bullet under
+    // the `### Skills You Can Use` subsection.
+    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content:
+          'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
+      },
+    ]);
 
     const result = await injectMemoryV2Block({
       database: db,
@@ -706,16 +802,12 @@ describe("injectMemoryV2Block", () => {
       config: makeConfig(),
     });
 
-    expect(result.toInject).toEqual([]);
+    expect(result.toInject).toEqual(["skills/example-skill-a"]);
     expect(result.block).not.toBeNull();
-    // `block` is the unwrapped inner content; the caller adds the
-    // `<memory>...</memory>` wrapper exactly once at injection time.
     expect(result.block).not.toContain("<memory>");
     expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
-    // No concept-page sections; skills subsection present with the right
-    // bullet shape and the unconditional `→ use skill_load to activate` suffix.
-    expect(result.block).not.toContain("### alice-vscode");
+    expect(result.block).not.toContain("# memory/concepts/alice-vscode.md");
     expect(result.block).toContain("### Skills You Can Use");
     expect(result.block).toContain(
       '- The "Example Skill A" skill (example-skill-a) is available. Helps with examples. → use skill_load to activate',
@@ -723,19 +815,19 @@ describe("injectMemoryV2Block", () => {
   });
 
   test("renders concept-page sections before the skills subsection in mixed blocks", async () => {
-    // Concept page hits AND a skill — concept-page sections come first, then
+    // Concept page hit AND a skill — concept-page sections come first, then
     // the skills subsection.
-    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
-    stageSkills(
-      ["example-skill-a"],
-      [
-        {
-          id: "example-skill-a",
-          content:
-            'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
-        },
-      ],
-    );
+    stageTurn([
+      { slug: "alice-vscode", denseScore: 0.9 },
+      { slug: "skills/example-skill-a", denseScore: 0.7 },
+    ]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content:
+          'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
+      },
+    ]);
 
     const result = await injectMemoryV2Block({
       database: db,
@@ -748,55 +840,34 @@ describe("injectMemoryV2Block", () => {
       config: makeConfig(),
     });
 
-    expect(result.toInject).toEqual(["alice-vscode"]);
+    // Both slugs ranked into top-K and got freshly attached.
+    expect(new Set(result.toInject)).toEqual(
+      new Set(["alice-vscode", "skills/example-skill-a"]),
+    );
     expect(result.block).not.toBeNull();
 
-    const aliceIdx = result.block!.indexOf("### alice-vscode");
+    const aliceHeaderIdx = result.block!.indexOf(
+      "# memory/concepts/alice-vscode.md",
+    );
     const skillsIdx = result.block!.indexOf("### Skills You Can Use");
-    expect(aliceIdx).toBeGreaterThan(-1);
+    expect(aliceHeaderIdx).toBeGreaterThan(-1);
     expect(skillsIdx).toBeGreaterThan(-1);
-    expect(aliceIdx).toBeLessThan(skillsIdx);
+    expect(aliceHeaderIdx).toBeLessThan(skillsIdx);
 
-    // The activation suffix is always appended for skills.
     expect(result.block).toContain(
       '- The "Example Skill A" skill (example-skill-a) is available. Helps with examples. → use skill_load to activate',
     );
   });
 
-  test("returns null when both concept pages and skills are empty", async () => {
-    // Empty concept-page candidate set (all simBatch + ANN responses empty)
-    // AND no skill ids.
-    stageTurn([]);
-    stageSkills([]);
-
-    const result = await injectMemoryV2Block({
-      database: db,
-      conversationId: "conv-1",
-      currentTurn: 1,
-      userMessage: "anything",
-      assistantMessage: "",
-      nowText: "",
-      messageId: "msg-1",
-      config: makeConfig(),
-    });
-
-    expect(result.toInject).toEqual([]);
-    expect(result.block).toBeNull();
-  });
-
-  test("re-renders the same top-ranked skill on consecutive turns (no dedup)", async () => {
-    // Skills are stateless: the same id can appear on back-to-back turns.
-    // Stage no concept-page candidates so the block content is purely the
-    // skills subsection.
+  test("skills participate in everInjected — an attached skill is not re-attached on the next turn", async () => {
+    // Turn 1: skill ranks high, gets attached.
     const skillEntry = {
       id: "example-skill-a",
       content:
         'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
     };
-
-    // Turn 1 — only the skill.
-    stageTurn([]);
-    stageSkills(["example-skill-a"], [skillEntry]);
+    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageSkills([skillEntry]);
     const result1 = await injectMemoryV2Block({
       database: db,
       conversationId: "conv-1",
@@ -807,15 +878,14 @@ describe("injectMemoryV2Block", () => {
       messageId: "msg-1",
       config: makeConfig(),
     });
-    expect(result1.block).not.toBeNull();
+    expect(result1.toInject).toEqual(["skills/example-skill-a"]);
     expect(result1.block).toContain("### Skills You Can Use");
-    expect(result1.block).toContain("example-skill-a");
 
-    // Turn 2 — same skill ranks top again. Persisted state has advanced (the
-    // first call wrote a fresh activation_state row), and `everInjected` was
-    // not touched by the skill pipeline. The skill must still appear.
-    stageTurn([]);
-    stageSkills(["example-skill-a"], [skillEntry]);
+    // Turn 2: same skill ranks top again. It is already in `everInjected`, so
+    // `toInject` is empty and the block is null — the attachment from turn 1
+    // remains visible to the agent via the cached prior user message.
+    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageSkills([skillEntry]);
     const result2 = await injectMemoryV2Block({
       database: db,
       conversationId: "conv-1",
@@ -826,21 +896,57 @@ describe("injectMemoryV2Block", () => {
       messageId: "msg-2",
       config: makeConfig(),
     });
-    expect(result2.block).not.toBeNull();
-    expect(result2.block).toContain("### Skills You Can Use");
-    expect(result2.block).toContain("example-skill-a");
-
-    // The skill content line is identical across the two turns — the renderer
-    // is deterministic in `id → entry` lookup and the entry is unchanged.
-    const skillLine =
-      '- The "Example Skill A" skill (example-skill-a) is available. Helps with examples. → use skill_load to activate';
-    expect(result1.block).toContain(skillLine);
-    expect(result2.block).toContain(skillLine);
-
-    // `everInjected` is untouched by the skill pipeline — both turns left it
-    // empty (no concept pages were injected).
+    expect(result2.toInject).toEqual([]);
+    expect(result2.block).toBeNull();
+
     const persisted = await hydrate(db, "conv-1");
-    expect(persisted!.everInjected).toEqual([]);
+    expect(persisted!.everInjected).toEqual([
+      { slug: "skills/example-skill-a", turn: 1 },
+    ]);
+  });
+
+  test("skill slugs whose entry is missing from the cache are dropped silently", async () => {
+    // The skill ranks into top-K but the in-process cache no longer knows
+    // its content (skill uninstalled mid-run). The render path drops it
+    // without surfacing it as a `missingSlugs` page-missing event — that
+    // status is reserved for on-disk concept pages, not catalog-derived
+    // skill entries.
+    stageTurn([{ slug: "skills/missing-skill", denseScore: 0.9 }]);
+    // No `stageSkills` call — cache stays empty.
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "anything",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    // `toInject` still records the slug (it ranked into top-K) but the
+    // block collapses to null because the only entry was a cache miss.
+    expect(result.toInject).toEqual(["skills/missing-skill"]);
+    expect(result.block).toBeNull();
+  });
+
+  test("returns null when both concept pages and skills are empty", async () => {
+    stageTurn([]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "anything",
+      assistantMessage: "",
+      nowText: "",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(result.toInject).toEqual([]);
+    expect(result.block).toBeNull();
   });
 
   test("context-load mode renders topNow even when every slug was previously injected", async () => {
@@ -875,7 +981,7 @@ describe("injectMemoryV2Block", () => {
     });
 
     expect(result.block).not.toBeNull();
-    expect(result.block).toContain("### alice-vscode");
+    expect(result.block).toContain("# memory/concepts/alice-vscode.md");
     // No newly-injected slug — alice was already in everInjected.
     expect(result.toInject).toEqual([]);
 
@@ -911,9 +1017,9 @@ describe("injectMemoryV2Block", () => {
     });
 
     expect(result.block).not.toBeNull();
-    expect(result.block).toContain("### alice-vscode");
-    expect(result.block).toContain("### bob-coffee");
-    expect(result.block).toContain("### carol-jazz");
+    expect(result.block).toContain("# memory/concepts/alice-vscode.md");
+    expect(result.block).toContain("# memory/concepts/bob-coffee.md");
+    expect(result.block).toContain("# memory/concepts/carol-jazz.md");
     // The seeded directed edges (alice→bob, bob→alice, frontmatter-demo→alice)
     // mean alice has two incoming predecessors and bob has one, so directed
     // spread normalizes alice's activation more aggressively than bob's. The
@@ -932,39 +1038,6 @@ describe("injectMemoryV2Block", () => {
     expect(persisted!.everInjected).toHaveLength(3);
   });
 
-  test("`top_k_skills: 0` short-circuits to no skills subsection", async () => {
-    // Even when the underlying mock would surface skills, the cap at 0 must
-    // drop them via `selectSkillInjections.topK = 0` → empty `topNow`.
-    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
-    stageSkills(
-      ["example-skill-a"],
-      [
-        {
-          id: "example-skill-a",
-          content:
-            'The "Example Skill A" skill (example-skill-a) is available.',
-        },
-      ],
-    );
-
-    const result = await injectMemoryV2Block({
-      database: db,
-      conversationId: "conv-1",
-      currentTurn: 1,
-      userMessage: "Alice's editor",
-      assistantMessage: "",
-      nowText: "Now",
-      messageId: "msg-1",
-      config: makeConfig({ top_k_skills: 0 }),
-    });
-
-    expect(result.toInject).toEqual(["alice-vscode"]);
-    expect(result.block).not.toBeNull();
-    expect(result.block).toContain("### alice-vscode");
-    expect(result.block).not.toContain("### Skills You Can Use");
-    expect(result.block).not.toContain("example-skill-a");
-  });
-
   // ---------------------------------------------------------------------------
   // Activation-log telemetry
   // ---------------------------------------------------------------------------
@@ -1013,13 +1086,12 @@ describe("injectMemoryV2Block", () => {
         status: string;
         source: string;
       }>;
-      skills: unknown[];
       config: { top_k: number };
     };
     expect(row.conversationId).toBe("conv-1");
     expect(row.turn).toBe(2);
     expect(row.mode).toBe("per-turn");
-    expect(row.config.top_k).toBe(20);
+    expect(row.config.top_k).toBe(25);
 
     // The candidate set is the union of fromPrior (alice) and fromAnn
     // (alice + carol) → two concept rows.
@@ -1041,6 +1113,41 @@ describe("injectMemoryV2Block", () => {
     expect(byslug.get("carol-jazz")!.status).toBe("injected");
   });
 
+  test("activation-log concepts include skill rows under the skills/ prefix", async () => {
+    // Skills participate in the unified telemetry list — they live in the
+    // same `concepts` array, identifiable by the `skills/` slug prefix.
+    stageTurn([
+      { slug: "alice-vscode", denseScore: 0.9 },
+      { slug: "skills/example-skill-a", denseScore: 0.7 },
+    ]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content: "skill content",
+      },
+    ]);
+
+    await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "Alice's editor",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(telemetryState.recordCalls.length).toBe(1);
+    const row = telemetryState.recordCalls[0] as {
+      concepts: Array<{ slug: string; status: string }>;
+    };
+    const slugs = row.concepts.map((c) => c.slug);
+    expect(new Set(slugs)).toEqual(
+      new Set(["alice-vscode", "skills/example-skill-a"]),
+    );
+  });
+
   test("context-load mode marks every rendered slug as `injected`, never `in_context`", async () => {
     // Turn 1 (per-turn): seed alice as injected so the next turn's prior
     // `everInjected` includes her — the same setup the per-turn telemetry
@@ -1173,7 +1280,7 @@ describe("injectMemoryV2Block", () => {
     expect(telemetryState.recordCalls.length).toBe(0);
     expect(result.toInject).toEqual(["alice-vscode"]);
     expect(result.block).not.toBeNull();
-    expect(result.block).toContain("### alice-vscode");
+    expect(result.block).toContain("# memory/concepts/alice-vscode.md");
 
     const persisted = await hydrate(db, "conv-1");
     expect(persisted!.everInjected).toEqual([