@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

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

@@ -0,0 +1,592 @@
+/**
+ * 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` 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 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, 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";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+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 { 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/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 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 = {
+  ...(await import("../../../../memory/v2/page-store.js")),
+};
+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 ────────────────────────────
+
+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 () => ({
+  currentSelections: [
+    { slug: "page-1", pinned: true },
+    { slug: "page-2", pinned: false },
+    { slug: "page-3", pinned: false },
+  ],
+  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 sectionBuilds = 0;
+let needleBuilds = 0;
+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.
+let testSqlite: Database;
+let testDb = makeDb();
+function makeDb() {
+  testSqlite = new Database(":memory:");
+  testSqlite.exec("PRAGMA journal_mode=WAL");
+  const db = drizzle(testSqlite, { schema });
+  migrateAddMemoryV3Selections(db);
+  return db;
+}
+
+const FAKE_SECTION_INDEX: SectionIndex = {
+  sections: [],
+  byArticle: new Map(),
+};
+
+// ─── module mocks (installed before the plugin import) ──────────────────────
+
+mock.module("../../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) =>
+    key === "memory-v3-live"
+      ? liveEnabled
+      : key === "memory-v3-shadow"
+        ? shadowEnabled
+        : false,
+}));
+
+mock.module("../../../../config/loader.js", () => ({
+  getConfig: () => ({
+    memory: {
+      v3: {
+        workingSet: { maxPages: 150, evictWindow: 5 },
+        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
+// stays present; only `getMessages` is overridden.
+mock.module("../../../../memory/conversation-crud.js", () => ({
+  ...realConversationCrud,
+  getMessages: () => messages.map((m, i) => ({ ...m, id: `m${i}` })),
+}));
+
+mock.module("../../../../memory/db-connection.js", () => ({
+  getDb: () => testDb,
+  getSqliteFrom: () => testSqlite,
+}));
+
+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`.
+mock.module("../../../../memory/v2/page-store.js", () => ({
+  ...realPageStore,
+  readPage: async (workspaceDir: string, slug: string) =>
+    shadowMockActive
+      ? { slug, frontmatter: {}, body: `body for ${slug}` }
+      : realPageStore.readPage(workspaceDir, slug),
+  renderPageContent: (page: { slug: string; body: string }) =>
+    shadowMockActive
+      ? page.body
+      : realPageStore.renderPageContent(
+          page as Parameters<typeof realPageStore.renderPageContent>[0],
+        ),
+}));
+
+mock.module("../../../../util/platform.js", () => ({
+  ...realPlatform,
+  getWorkspaceDir: () =>
+    shadowMockActive
+      ? "/tmp/shadow-test-workspace"
+      : realPlatform.getWorkspaceDir(),
+}));
+
+// 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
+      ? null
+      : realCliCommandStore.getCliCommandCapability(idOrSlug),
+}));
+
+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("../section-needle.js", () => ({
+  ...realSectionNeedle,
+  buildSectionNeedle: (
+    ...args: Parameters<typeof realSectionNeedle.buildSectionNeedle>
+  ) => {
+    if (!shadowMockActive) return realSectionNeedle.buildSectionNeedle(...args);
+    needleBuilds++;
+    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");
+  },
+}));
+
+mock.module("../orchestrate.js", () => ({
+  ...realOrchestrate,
+  orchestrate: (...args: Parameters<typeof realOrchestrate.orchestrate>) =>
+    shadowMockActive
+      ? orchestrateSpy(...(args as unknown as []))
+      : realOrchestrate.orchestrate(...args),
+}));
+
+// Import AFTER mocks so the plugin binds to them.
+const { runShadowObservation, resetShadowLanesForTests, invalidateLanes } =
+  await import("../shadow-plugin.js");
+const { memoryV3Injector } = await import("../injector.js");
+
+afterAll(() => {
+  shadowMockActive = false;
+});
+
+function readRows() {
+  return testSqlite
+    .query(
+      `SELECT slug, source, pinned FROM memory_v3_selections ORDER BY slug`,
+    )
+    .all() as Array<{ slug: string; source: SelectionSource; pinned: number }>;
+}
+
+beforeEach(() => {
+  shadowMockActive = true;
+  liveEnabled = false;
+  shadowEnabled = false;
+  messages = [
+    {
+      role: "user",
+      content: JSON.stringify([{ type: "text", text: "hello world" }]),
+    },
+  ];
+  orchestrateSpy.mockClear();
+  sectionBuilds = 0;
+  needleBuilds = 0;
+  edgeBuilds = 0;
+  ensureCollectionCalls = 0;
+  ensureCollectionThrows = false;
+  capturedPageBody = null;
+  testDb = makeDb();
+  resetShadowLanesForTests();
+});
+
+/** Invoke the memory-v3 injector's `produce()` for a turn. */
+function produce(conversationId: string, turnIndex: number) {
+  return memoryV3Injector.produce({
+    requestId: "r1",
+    conversationId,
+    turnIndex,
+    trust: {} as never,
+  });
+}
+
+describe("memory-v3 shadow plugin", () => {
+  test("shadow flag OFF → orchestrate not called, no DB writes", async () => {
+    shadowEnabled = false;
+    await runShadowObservation("conv-1", 0);
+    expect(orchestrateSpy).not.toHaveBeenCalled();
+    expect(sectionBuilds).toBe(0);
+    expect(readRows()).toHaveLength(0);
+  });
+
+  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: "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 },
+    ]);
+  });
+
+  test("the turn passed to orchestrate carries the latest user message", async () => {
+    shadowEnabled = true;
+    await runShadowObservation("conv-1", 0);
+    const turn = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![0] as {
+      conversationId: string;
+      turnNumber: number;
+      currentMessage: string;
+    };
+    expect(turn.conversationId).toBe("conv-1");
+    expect(turn.turnNumber).toBe(0);
+    expect(turn.currentMessage).toBe("hello world");
+  });
+
+  test("orchestrate receives the lane deps", async () => {
+    shadowEnabled = true;
+    await runShadowObservation("conv-1", 0);
+    const deps = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![1] as {
+      sectionIndex?: unknown;
+      needle?: unknown;
+      edgeGraph?: unknown;
+      workingSet?: unknown;
+    };
+    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 () => {
+    liveEnabled = false;
+    shadowEnabled = false;
+    const block = await produce("conv-1", 0);
+    expect(block).toBeNull();
+    expect(orchestrateSpy).not.toHaveBeenCalled();
+    expect(readRows()).toHaveLength(0);
+  });
+
+  test("shadow-only (live off) → produce returns null but still logs", async () => {
+    liveEnabled = false;
+    shadowEnabled = true;
+    const block = await produce("conv-1", 0);
+    expect(block).toBeNull();
+    expect(orchestrateSpy).toHaveBeenCalledTimes(1);
+    expect(readRows().length).toBeGreaterThan(0);
+  });
+
+  test("live on → produce returns the rendered <memory> block and logs", async () => {
+    liveEnabled = true;
+    shadowEnabled = false;
+    const block = await produce("conv-1", 0);
+    expect(block).not.toBeNull();
+    expect(block!.placement).toBe("after-memory-prefix");
+    expect(block!.text.startsWith("<memory>\n")).toBe(true);
+    expect(block!.text.endsWith("\n</memory>")).toBe(true);
+    // 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);
+  });
+
+  test("live on but empty selection → produce returns null", async () => {
+    liveEnabled = true;
+    shadowEnabled = false;
+    orchestrateSpy.mockImplementationOnce(async () => ({
+      currentSelections: [],
+      workingSetUnion: new Set<string>(),
+      finalInjection: [],
+      sectionBySlug: new Map(),
+      laneBySlug: new Map(),
+    }));
+    const block = await produce("conv-1", 0);
+    expect(block).toBeNull();
+    expect(orchestrateSpy).toHaveBeenCalledTimes(1);
+    expect(readRows()).toHaveLength(0);
+  });
+
+  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(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);
+    expect(sectionBuilds).toBe(1);
+    expect(needleBuilds).toBe(1);
+
+    invalidateLanes();
+
+    await runShadowObservation("conv-1", 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(sectionBuilds).toBe(2);
+    expect(needleBuilds).toBe(2);
+  });
+
+  test("resetShadowLanesForTests invalidates like invalidateLanes", async () => {
+    shadowEnabled = true;
+    await runShadowObservation("conv-1", 0);
+    expect(sectionBuilds).toBe(1);
+
+    resetShadowLanesForTests();
+
+    await runShadowObservation("conv-1", 1);
+    expect(sectionBuilds).toBe(2);
+  });
+
+  test("concurrent first turns after invalidation share a single build", async () => {
+    shadowEnabled = true;
+    await runShadowObservation("conv-1", 0);
+    expect(sectionBuilds).toBe(1);
+
+    invalidateLanes();
+
+    await Promise.all([
+      runShadowObservation("conv-1", 1),
+      runShadowObservation("conv-1", 2),
+    ]);
+    expect(sectionBuilds).toBe(2);
+    expect(needleBuilds).toBe(2);
+  });
+
+  test("no user message → no orchestrate, no writes", async () => {
+    shadowEnabled = true;
+    messages = [
+      {
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "hi" }]),
+      },
+    ];
+    await runShadowObservation("conv-1", 0);
+    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/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/types.test.ts

@@ -1,35 +1,15 @@
 import { expect, test } from "bun:test";
 
 import type {
-  LeafFrontmatter,
-  LeafNode,
-  LeafPath,
-  LeafTree,
+  MemoryRoutingTurn,
   SelectionSource,
   Slug,
-  TurnContext,
   WorkingSetEntry,
 } 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,
@@ -37,7 +17,7 @@ test("v3 core types instantiate", () => {
     lastSeenTurn: 2,
   };
 
-  const turnContext: TurnContext = {
+  const turnContext: MemoryRoutingTurn = {
     conversationId: "conv-xyz",
     turnNumber: 3,
     currentMessage: "hello",
@@ -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");