@vellumai/assistant 0.8.9-staging.2 → 0.8.9-staging.4

package/src/plugins/defaults/memory-v3-shadow/__tests__/shadow-plugin.test.ts

@@ -1,20 +1,25 @@
 /**
- * Tests for `assistant/src/memory/v3/shadow-plugin.ts`.
+ * Tests for `shadow-plugin.ts` (section-lane pipeline).
  *
  * The v3 plugin is flag-gated. These tests assert:
  *   - both flags OFF → orchestrate is never called and no DB rows are written;
  *   - either flag ON → orchestrate runs and selection rows land in
- *     `memory_v3_selections`;
+ *     `memory_v3_selections` with the new lane source tags;
  *   - shadow-only (live off) → the injector returns `null` (never mutates the
  *     turn) but still logs;
  *   - live on → the injector returns the rendered `<memory>` block;
  *   - an empty selection under live → `null`;
- *   - lazy-init runs the loaders only once across multiple turns.
+ *   - lazy-init runs the lane builders only once across multiple turns, and
+ *     `invalidateLanes` forces exactly one rebuild;
+ *   - `initLanes` feeds synthetic capability pages (skills / CLI commands) into
+ *     the section index via `renderCapabilityContent`, so the needle lane ranks
+ *     them like any other page (they are no longer always-added to the pool).
  *
  * All heavy dependencies (config, flag resolver, conversation reads, v2 page
- * index + page store, v3 loaders, orchestrate) are mocked BEFORE importing the
- * plugin so the module observes them at load time. A real in-memory SQLite DB
- * backs the write assertions via the `memory_v3_selections` migration.
+ * index + page store, the lane builders, orchestrate) are mocked BEFORE
+ * importing the plugin so the module observes them at load time. A real
+ * in-memory SQLite DB backs the write assertions via the
+ * `memory_v3_selections` migration.
  */
 
 import { Database } from "bun:sqlite";
@@ -24,22 +29,25 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { migrateAddMemoryV3Selections } from "../../../../memory/migrations/268-add-memory-v3-selections.js";
 import * as schema from "../../../../memory/schema.js";
-import type { LeafTree, SelectionSource } from "../types.js";
+import type { CandidateLane, SectionIndex, SelectionSource } from "../types.js";
 
 // `mock.module` is process-global and, in Bun, neither `mock.restore()` nor a
 // re-mock in `afterAll` reverts it for files that load LATER in the same
-// `bun test src/memory/v3/` run. Sibling files (orchestrate.test.ts,
-// tree.test.ts) import these same modules for real, so an unconditional stub
-// here would leak in and break them. Instead each stub below DELEGATES to the
-// real implementation unless this test is actively running (`shadowMockActive`,
-// toggled in beforeEach/afterAll).
+// `bun test src/plugins/defaults/memory-v3-shadow/` run. Sibling files import
+// these same modules for real, so an unconditional stub here would leak in and
+// break them. Instead each stub below DELEGATES to the real implementation
+// unless this test is actively running (`shadowMockActive`, toggled in
+// beforeEach/afterAll).
 //
 // Snapshot the real exports into plain objects NOW: a module namespace object
-// is a live view, so reading `realTree.loadLeafTree` *after* the stub is
-// installed would resolve back to the stub (infinite recursion).
-const realTree = { ...(await import("../tree.js")) };
-const realCore = { ...(await import("../core.js")) };
-const realNeedle = { ...(await import("../needle.js")) };
+// is a live view, so reading the real export *after* the stub is installed
+// would resolve back to the stub (infinite recursion).
+const realSections = { ...(await import("../sections.js")) };
+const realSectionNeedle = { ...(await import("../section-needle.js")) };
+const realEdge = { ...(await import("../edge.js")) };
+const realSectionDenseStore = {
+  ...(await import("../section-dense-store.js")),
+};
 const realOrchestrate = { ...(await import("../orchestrate.js")) };
 const realPlatform = { ...(await import("../../../../util/platform.js")) };
 const realPageStore = {
@@ -48,33 +56,65 @@ const realPageStore = {
 const realConversationCrud = {
   ...(await import("../../../../memory/conversation-crud.js")),
 };
+const realSkillStore = {
+  ...(await import("../../../../memory/v2/skill-store.js")),
+};
+const realCliCommandStore = {
+  ...(await import("../../../../memory/v2/cli-command-store.js")),
+};
 
 let shadowMockActive = false;
 
 // ─── mutable test state, read by the mocks below ────────────────────────────
 
-// Per-flag toggles. The plugin reads `memory-v3-live` and `memory-v3-shadow`
-// independently, so the mock resolves by flag key rather than a single boolean.
 let liveEnabled = false;
 let shadowEnabled = false;
 let messages: Array<{ role: string; content: string }> = [];
+
+// A synthetic skill capability slug the page index carries. Its rendered
+// content holds a distinctive term ("kumquat") so the real needle, built over
+// the section index `initLanes` feeds, ranks it. Generic placeholder only.
+const CAPABILITY_SLUG = "skills/example";
+const CAPABILITY_CONTENT = "use the kumquat skill to do the thing";
+
+// The orchestrate result the spy returns. `laneBySlug` records the lane that
+// surfaced each pooled slug: page-1 → "needle", page-2 → "dense", page-3 →
+// "edge"; `attributeSelections` reads it directly. `carried` is a carry-forward
+// slug not re-selected this turn. `sectionBySlug` carries the matched section
+// for the slugs that had one (page-1/page-2) — consumed by the live injector's
+// progressive disclosure, independent of source attribution.
 const orchestrateSpy = mock(async () => ({
-  openedLeaves: [],
   currentSelections: [
-    { slug: "domain-a/page-1", pinned: true },
-    { slug: "domain-b/page-2", pinned: false },
+    { slug: "page-1", pinned: true },
+    { slug: "page-2", pinned: false },
+    { slug: "page-3", pinned: false },
   ],
-  workingSetUnion: new Set<string>(["domain-a/page-1", "domain-b/page-2"]),
-  finalInjection: ["domain-a/page-1", "domain-b/page-2", "domain-a/carried"],
+  workingSetUnion: new Set<string>(["page-1", "page-2", "page-3"]),
+  finalInjection: ["page-1", "page-2", "page-3", "carried"],
+  sectionBySlug: new Map([
+    ["page-1", { article: "page-1", title: "", text: "x", ordinal: 0 }],
+    ["page-2", { article: "page-2", title: "", text: "y", ordinal: 0 }],
+  ]),
+  laneBySlug: new Map<string, CandidateLane>([
+    ["page-1", "needle"],
+    ["page-2", "dense"],
+    ["page-3", "edge"],
+  ]),
 }));
-let treeLoads = 0;
-let coreLoads = 0;
+
+let sectionBuilds = 0;
 let needleBuilds = 0;
-let configL2Concurrency = 16;
+let edgeBuilds = 0;
+let ensureCollectionCalls = 0;
+let ensureCollectionThrows = false;
+
+// The `pageBody` resolver `initLanes` passes to `buildSectionIndex` (its second
+// arg), captured by the stub below so a test can drive it directly: a capability
+// slug must resolve to its rendered capability content, an on-disk slug to its
+// page body.
+let capturedPageBody: ((slug: string) => Promise<string>) | null = null;
 
-// Shared in-memory DB so writes are observable from the test. We hold the raw
-// sqlite handle alongside the drizzle wrapper so the test can both read rows
-// directly and feed the same handle through the mocked `getSqliteFrom`.
+// Shared in-memory DB so writes are observable from the test.
 let testSqlite: Database;
 let testDb = makeDb();
 function makeDb() {
@@ -85,15 +125,10 @@ function makeDb() {
   return db;
 }
 
-// A tree where `domain-a/*` pages are owned by a core leaf and `domain-b/*`
-// are not, so attribution maps to core+l2 / l1+l2 respectively.
-const FAKE_TREE = {
-  leaves: new Map([
-    ["domain-a", { members: ["domain-a/page-1", "domain-a/carried"] }],
-    ["domain-b", { members: ["domain-b/page-2"] }],
-  ]),
-  byPage: new Map(),
-} as unknown as LeafTree;
+const FAKE_SECTION_INDEX: SectionIndex = {
+  sections: [],
+  byArticle: new Map(),
+};
 
 // ─── module mocks (installed before the plugin import) ──────────────────────
 
@@ -111,16 +146,17 @@ mock.module("../../../../config/loader.js", () => ({
     memory: {
       v3: {
         workingSet: { maxPages: 150, evictWindow: 5 },
-        l2Concurrency: configL2Concurrency,
+        needleK: 100,
+        denseK: 100,
+        edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
       },
+      qdrant: { vectorSize: 8, onDisk: false },
     },
   }),
 }));
 
 // Spread the real module so every export the live path transitively imports
-// (e.g. `getMessageById` via page-content.ts) stays present — replacing the
-// whole module with a bare `{ getMessages }` made those consumers fail to load.
-// Only `getMessages` is overridden, since that's the one the plugin reads.
+// stays present; only `getMessages` is overridden.
 mock.module("../../../../memory/conversation-crud.js", () => ({
   ...realConversationCrud,
   getMessages: () => messages.map((m, i) => ({ ...m, id: `m${i}` })),
@@ -131,13 +167,42 @@ mock.module("../../../../memory/db-connection.js", () => ({
   getSqliteFrom: () => testSqlite,
 }));
 
-mock.module("../v2/page-index.js", () => ({
-  getPageIndex: async () => ({ bySlug: new Map() }),
+mock.module("../../../../memory/v2/page-index.js", () => ({
+  getPageIndex: async () => ({
+    entries: [
+      {
+        slug: "page-1",
+        id: 1,
+        summary: "",
+        edges: [],
+        leaves: [],
+        modifiedAt: 0,
+      },
+      {
+        slug: "page-2",
+        id: 2,
+        summary: "",
+        edges: [],
+        leaves: [],
+        modifiedAt: 0,
+      },
+      // A synthetic capability row — same shape the v2 page index appends for
+      // skills/CLI commands. `initLanes` must route it through the capability
+      // resolver, not an on-disk read.
+      {
+        slug: CAPABILITY_SLUG,
+        id: 3,
+        summary: "",
+        edges: [],
+        leaves: [],
+        modifiedAt: 0,
+      },
+    ],
+    bySlug: new Map(),
+  }),
 }));
 
 // `pageContent` (live mode) reads the full page via `readPage`/`renderPageContent`.
-// Stub them to return a deterministic body per slug so the rendered `<memory>`
-// block is assertable without touching the filesystem.
 mock.module("../../../../memory/v2/page-store.js", () => ({
   ...realPageStore,
   readPage: async (workspaceDir: string, slug: string) =>
@@ -160,41 +225,74 @@ mock.module("../../../../util/platform.js", () => ({
       : realPlatform.getWorkspaceDir(),
 }));
 
-mock.module("../tree.js", () => ({
-  ...realTree,
-  resolveDataDir: () =>
-    shadowMockActive ? "/tmp/shadow-test-data" : realTree.resolveDataDir(),
-  loadLeafTree: async (dataDir: string) => {
-    if (!shadowMockActive) return realTree.loadLeafTree(dataDir);
-    treeLoads++;
-    return FAKE_TREE;
-  },
-  membersOf: (tree: LeafTree, leaf: string) =>
+// Capability stores: `renderCapabilityContent` (reached from `initLanes`' pageBody
+// and from the live injector) resolves synthetic slugs through these. Spread the
+// real module so the prefix predicates (`isSkillSlug`/`isCliCommandSlug`) stay
+// intact; override only the content lookup so the capability slug resolves.
+mock.module("../../../../memory/v2/skill-store.js", () => ({
+  ...realSkillStore,
+  getSkillCapability: (idOrSlug: string) =>
+    shadowMockActive
+      ? idOrSlug === CAPABILITY_SLUG
+        ? { id: "example", content: CAPABILITY_CONTENT }
+        : null
+      : realSkillStore.getSkillCapability(idOrSlug),
+}));
+
+mock.module("../../../../memory/v2/cli-command-store.js", () => ({
+  ...realCliCommandStore,
+  getCliCommandCapability: (idOrSlug: string) =>
     shadowMockActive
-      ? ((tree.leaves.get(leaf) as unknown as { members?: string[] })
-          ?.members ?? [])
-      : realTree.membersOf(tree, leaf),
+      ? null
+      : realCliCommandStore.getCliCommandCapability(idOrSlug),
 }));
 
-mock.module("../core.js", () => ({
-  ...realCore,
-  loadCore: async (dataDir: string) => {
-    if (!shadowMockActive) return realCore.loadCore(dataDir);
-    coreLoads++;
-    return new Set(["domain-a"]);
+mock.module("../sections.js", () => ({
+  ...realSections,
+  buildSectionIndex: async (
+    ...args: Parameters<typeof realSections.buildSectionIndex>
+  ) => {
+    if (!shadowMockActive) return realSections.buildSectionIndex(...args);
+    sectionBuilds++;
+    // Capture the `pageBody` resolver so a test can exercise the capability
+    // branch directly. Returning the FAKE index keeps the other tests cheap.
+    capturedPageBody = args[1];
+    return FAKE_SECTION_INDEX;
   },
 }));
 
-mock.module("../needle.js", () => ({
-  ...realNeedle,
-  buildNeedleIndex: async (
-    ...args: Parameters<typeof realNeedle.buildNeedleIndex>
+mock.module("../section-needle.js", () => ({
+  ...realSectionNeedle,
+  buildSectionNeedle: (
+    ...args: Parameters<typeof realSectionNeedle.buildSectionNeedle>
   ) => {
-    if (!shadowMockActive) return realNeedle.buildNeedleIndex(...args);
+    if (!shadowMockActive) return realSectionNeedle.buildSectionNeedle(...args);
     needleBuilds++;
-    return { query: () => [] } as unknown as Awaited<
-      ReturnType<typeof realNeedle.buildNeedleIndex>
-    >;
+    return { query: () => [], bestSection: () => -1 };
+  },
+}));
+
+mock.module("../edge.js", () => ({
+  ...realEdge,
+  buildEdgeGraph: async (
+    ...args: Parameters<typeof realEdge.buildEdgeGraph>
+  ) => {
+    if (!shadowMockActive) return realEdge.buildEdgeGraph(...args);
+    edgeBuilds++;
+    return { adjacency: new Map(), hubs: new Set(), slugs: new Set() };
+  },
+}));
+
+mock.module("../section-dense-store.js", () => ({
+  ...realSectionDenseStore,
+  ensureSectionCollection: async (
+    ...args: Parameters<typeof realSectionDenseStore.ensureSectionCollection>
+  ) => {
+    if (!shadowMockActive) {
+      return realSectionDenseStore.ensureSectionCollection(...args);
+    }
+    ensureCollectionCalls++;
+    if (ensureCollectionThrows) throw new Error("qdrant unavailable");
   },
 }));
 
@@ -211,9 +309,6 @@ const { runShadowObservation, resetShadowLanesForTests, invalidateLanes } =
   await import("../shadow-plugin.js");
 const { memoryV3Injector } = await import("../injector.js");
 
-// The module stubs above stay installed for the rest of the process (Bun can't
-// reliably uninstall them), but `shadowMockActive` gates their fake behavior to
-// this file's tests only, so later-loaded sibling files see real behavior.
 afterAll(() => {
   shadowMockActive = false;
 });
@@ -237,10 +332,12 @@ beforeEach(() => {
     },
   ];
   orchestrateSpy.mockClear();
-  treeLoads = 0;
-  coreLoads = 0;
+  sectionBuilds = 0;
   needleBuilds = 0;
-  configL2Concurrency = 16;
+  edgeBuilds = 0;
+  ensureCollectionCalls = 0;
+  ensureCollectionThrows = false;
+  capturedPageBody = null;
   testDb = makeDb();
   resetShadowLanesForTests();
 });
@@ -260,22 +357,27 @@ describe("memory-v3 shadow plugin", () => {
     shadowEnabled = false;
     await runShadowObservation("conv-1", 0);
     expect(orchestrateSpy).not.toHaveBeenCalled();
-    expect(treeLoads).toBe(0);
+    expect(sectionBuilds).toBe(0);
     expect(readRows()).toHaveLength(0);
   });
 
-  test("shadow flag ON → orchestrate runs and rows are written", async () => {
+  test("shadow flag ON → orchestrate runs and rows are written with per-lane sources", async () => {
     shadowEnabled = true;
     await runShadowObservation("conv-1", 2);
 
     expect(orchestrateSpy).toHaveBeenCalledTimes(1);
     const rows = readRows();
+    // Each selection is attributed to the lane that surfaced it
+    // (`result.laneBySlug`), not re-derived from section presence — so the
+    // dense-only page-2 logs "dense", not "needle".
     expect(rows).toEqual([
-      { slug: "domain-a/carried", source: "carry-forward", pinned: 0 },
-      // page-1 belongs to the core leaf `domain-a` → core+l2, pinned.
-      { slug: "domain-a/page-1", source: "core+l2", pinned: 1 },
-      // page-2 belongs to non-core `domain-b` → l1+l2.
-      { slug: "domain-b/page-2", source: "l1+l2", pinned: 0 },
+      { slug: "carried", source: "carry-forward", pinned: 0 },
+      // page-1 was surfaced by the needle lane → "needle", pinned.
+      { slug: "page-1", source: "needle", pinned: 1 },
+      // page-2 was surfaced by the dense lane → "dense".
+      { slug: "page-2", source: "dense", pinned: 0 },
+      // page-3 was surfaced by the edge lane → "edge".
+      { slug: "page-3", source: "edge", pinned: 0 },
     ]);
   });
 
@@ -294,16 +396,21 @@ describe("memory-v3 shadow plugin", () => {
     expect(turn.currentMessage).toBe("hello world");
   });
 
-  test("orchestrate receives the configured L2 concurrency", async () => {
+  test("orchestrate receives the lane deps", async () => {
     shadowEnabled = true;
-    configL2Concurrency = 9;
     await runShadowObservation("conv-1", 0);
     const deps = (
       orchestrateSpy.mock.calls as unknown as unknown[][]
     )[0]![1] as {
-      l2Concurrency?: number;
+      sectionIndex?: unknown;
+      needle?: unknown;
+      edgeGraph?: unknown;
+      workingSet?: unknown;
     };
-    expect(deps.l2Concurrency).toBe(9);
+    expect(deps.sectionIndex).toBeDefined();
+    expect(deps.needle).toBeDefined();
+    expect(deps.edgeGraph).toBeDefined();
+    expect(deps.workingSet).toBeDefined();
   });
 
   test("both flags OFF → produce returns null, no orchestrate, no writes", async () => {
@@ -332,9 +439,12 @@ describe("memory-v3 shadow plugin", () => {
     expect(block!.placement).toBe("after-memory-prefix");
     expect(block!.text.startsWith("<memory>\n")).toBe(true);
     expect(block!.text.endsWith("\n</memory>")).toBe(true);
-    // finalInjection slugs are rendered into the block in order.
-    expect(block!.text).toContain("body for domain-a/page-1");
-    expect(block!.text).toContain("body for domain-a/carried");
+    // Progressive disclosure: a slug with a matched section renders that
+    // section's text (page-1 → "x"), NOT the full page body.
+    expect(block!.text).toContain("# memory/concepts/page-1.md\nx");
+    expect(block!.text).not.toContain("body for page-1");
+    // A slug with no matched section (carry-forward) falls back to the full body.
+    expect(block!.text).toContain("body for carried");
     // Selections are still logged in live mode.
     expect(readRows().length).toBeGreaterThan(0);
   });
@@ -343,76 +453,87 @@ describe("memory-v3 shadow plugin", () => {
     liveEnabled = true;
     shadowEnabled = false;
     orchestrateSpy.mockImplementationOnce(async () => ({
-      openedLeaves: [],
       currentSelections: [],
       workingSetUnion: new Set<string>(),
       finalInjection: [],
+      sectionBySlug: new Map(),
+      laneBySlug: new Map(),
     }));
     const block = await produce("conv-1", 0);
     expect(block).toBeNull();
-    // Orchestration still ran (and logged nothing, since there were no rows).
     expect(orchestrateSpy).toHaveBeenCalledTimes(1);
     expect(readRows()).toHaveLength(0);
   });
 
-  test("lazy-init runs the loaders only once across turns", async () => {
+  test("lazy-init runs the lane builders only once across turns", async () => {
     shadowEnabled = true;
     await runShadowObservation("conv-1", 0);
     await runShadowObservation("conv-1", 1);
     await runShadowObservation("conv-1", 2);
-    expect(treeLoads).toBe(1);
-    expect(coreLoads).toBe(1);
+    expect(sectionBuilds).toBe(1);
     expect(needleBuilds).toBe(1);
+    expect(edgeBuilds).toBe(1);
+    expect(ensureCollectionCalls).toBe(1);
     expect(orchestrateSpy).toHaveBeenCalledTimes(3);
   });
 
+  test("a Qdrant section-collection failure does not disable the in-memory lanes", async () => {
+    shadowEnabled = true;
+    ensureCollectionThrows = true;
+    // initLanes still builds the needle + edge lanes and orchestrate runs — a
+    // Qdrant outage degrades only the dense lane, it does not take down all of v3
+    // (and does not poison the memoized lanes by rejecting init).
+    await runShadowObservation("conv-1", 0);
+    expect(needleBuilds).toBe(1);
+    expect(edgeBuilds).toBe(1);
+    expect(ensureCollectionCalls).toBe(1);
+    expect(orchestrateSpy).toHaveBeenCalledTimes(1);
+  });
+
   test("invalidateLanes forces a one-time rebuild on the next turn", async () => {
     shadowEnabled = true;
     await runShadowObservation("conv-1", 0);
     await runShadowObservation("conv-1", 1);
-    // One build so far; invalidation drops it.
-    expect(treeLoads).toBe(1);
+    expect(sectionBuilds).toBe(1);
     expect(needleBuilds).toBe(1);
 
     invalidateLanes();
 
-    // The next turn rebuilds (fresh tree load + fresh needle index)...
     await runShadowObservation("conv-1", 2);
-    expect(treeLoads).toBe(2);
-    expect(coreLoads).toBe(2);
+    expect(sectionBuilds).toBe(2);
     expect(needleBuilds).toBe(2);
+    expect(edgeBuilds).toBe(2);
 
     // ...and the rebuild is memoized again — no further builds until the next
     // invalidation.
     await runShadowObservation("conv-1", 3);
-    expect(treeLoads).toBe(2);
+    expect(sectionBuilds).toBe(2);
     expect(needleBuilds).toBe(2);
   });
 
   test("resetShadowLanesForTests invalidates like invalidateLanes", async () => {
     shadowEnabled = true;
     await runShadowObservation("conv-1", 0);
-    expect(treeLoads).toBe(1);
+    expect(sectionBuilds).toBe(1);
 
     resetShadowLanesForTests();
 
     await runShadowObservation("conv-1", 1);
-    expect(treeLoads).toBe(2);
+    expect(sectionBuilds).toBe(2);
   });
 
   test("concurrent first turns after invalidation share a single build", async () => {
     shadowEnabled = true;
     await runShadowObservation("conv-1", 0);
-    expect(treeLoads).toBe(1);
+    expect(sectionBuilds).toBe(1);
 
     invalidateLanes();
 
-    // Both turns race the rebuild; memoization must collapse them to one build.
     await Promise.all([
       runShadowObservation("conv-1", 1),
       runShadowObservation("conv-1", 2),
     ]);
-    expect(treeLoads).toBe(2);
+    expect(sectionBuilds).toBe(2);
     expect(needleBuilds).toBe(2);
   });
 
@@ -428,4 +549,44 @@ describe("memory-v3 shadow plugin", () => {
     expect(orchestrateSpy).not.toHaveBeenCalled();
     expect(readRows()).toHaveLength(0);
   });
+
+  describe("initLanes feeds synthetic capability pages into the section index", () => {
+    test("the pageBody resolver returns capability content for a synthetic slug and disk body otherwise", async () => {
+      shadowEnabled = true;
+      await runShadowObservation("conv-1", 0);
+
+      // `initLanes` ran the real pageBody-building closure and handed it to
+      // `buildSectionIndex`; the stub captured it.
+      expect(capturedPageBody).not.toBeNull();
+      const pageBody = capturedPageBody!;
+
+      // A capability slug resolves to its rendered capability content (NOT an
+      // on-disk read, which would miss), so the needle can rank it.
+      const capBody = await pageBody(CAPABILITY_SLUG);
+      expect(capBody).toContain("kumquat");
+      // On-disk slugs still resolve to their page body.
+      expect(await pageBody("page-1")).toBe("body for page-1");
+    });
+
+    test("a synthetic slug's capability content yields a section the needle ranks", async () => {
+      shadowEnabled = true;
+      await runShadowObservation("conv-1", 0);
+      const pageBody = capturedPageBody!;
+
+      // Feed the captured resolver through the REAL section builder + needle:
+      // the capability slug yields ≥1 section and is ranked on a term from its
+      // capability content — the path that makes synthetic pages lane-rankable.
+      const index = await realSections.buildSectionIndex(
+        [CAPABILITY_SLUG],
+        pageBody,
+      );
+      expect(index.byArticle.get(CAPABILITY_SLUG)?.length ?? 0).toBeGreaterThan(
+        0,
+      );
+
+      const needle = realSectionNeedle.buildSectionNeedle(index);
+      const hits = needle.query("kumquat", 5);
+      expect(hits.map((h) => h.article)).toContain(CAPABILITY_SLUG);
+    });
+  });
 });

package/src/plugins/defaults/memory-v3-shadow/__tests__/types.test.ts

@@ -1,10 +1,6 @@
 import { expect, test } from "bun:test";
 
 import type {
-  LeafFrontmatter,
-  LeafNode,
-  LeafPath,
-  LeafTree,
   MemoryRoutingTurn,
   SelectionSource,
   Slug,
@@ -12,24 +8,8 @@ import type {
 } from "../types.js";
 
 test("v3 core types instantiate", () => {
-  const path: LeafPath = "domain/topic/leaf";
   const slug: Slug = "page-123";
 
-  const frontmatter: LeafFrontmatter = { path, in_core: true };
-
-  const node: LeafNode = {
-    path,
-    frontmatter,
-    description: "an example leaf node",
-    members: [slug],
-    domain: "example",
-  };
-
-  const tree: LeafTree = {
-    leaves: new Map<LeafPath, LeafNode>([[path, node]]),
-    byPage: new Map<Slug, LeafPath[]>([[slug, [path]]]),
-  };
-
   const entry: WorkingSetEntry = {
     slug,
     selectedAtTurn: 1,
@@ -46,8 +26,6 @@ test("v3 core types instantiate", () => {
 
   const source: SelectionSource = "carry-forward";
 
-  expect(tree.leaves.get(path)).toBe(node);
-  expect(tree.byPage.get(slug)).toEqual([path]);
   expect(entry.slug).toBe(slug);
   expect(turnContext.turnNumber).toBe(3);
   expect(source).toBe("carry-forward");