@vellumai/assistant 0.8.5 → 0.8.7

package/src/memory/v2/harness/replay-input.ts

@@ -10,8 +10,10 @@
  *  - `nowText`: read from current workspace files (`loadNowText`). NOT stored
  *    in the log, so it may differ from what the live turn saw —
  *    always-approximate; see `ReconstructionMeta.nowReconstructedFromCurrent`.
- *  - `priorEverInjected`: the union of injected / in_context slugs from earlier
- *    `mode='router'` logs in the same conversation (turn < target).
+ *  - `priorEverInjected`: the union of retained slugs from earlier
+ *    `mode='router'` logs in the same conversation (turn < target). Retained
+ *    statuses mirror production's `everInjected` (injected / in_context, plus
+ *    page_missing / corrupt — see `PRIOR_STATUSES`).
  *
  * The anchor is the turn's assistant reply; the messages the router saw are
  * those strictly before it, so we fetch a bounded recent window up to the
@@ -172,7 +174,21 @@ export async function reconstructInput(
   };
 }
 
-const PRIOR_STATUSES = new Set<string>(["injected", "in_context"]);
+// Production's `everInjected` retains a slug once it is rendered, EXCEPT for
+// missing synthetic slugs (skills/CLI commands whose capability cache is empty
+// — see `missingSyntheticSlugs` in `injection.ts`). Concept pages that turn out
+// `page_missing` or `corrupt` at render time are still retained so they aren't
+// re-attempted every turn (see the `page_missing ... DOES land in everInjected`
+// case in `injection.test.ts`). The replay must mirror that retention or it
+// builds a narrower prior-state than live routing, skewing comparisons. Missing
+// synthetic slugs never enter the missing/corrupt buckets — they log as
+// `injected` — so widening here introduces no new synthetic-slug discrepancy.
+const PRIOR_STATUSES = new Set<string>([
+  "injected",
+  "in_context",
+  "page_missing",
+  "corrupt",
+]);
 
 /**
  * Union of slugs injected on earlier `mode='router'` turns in this conversation

package/src/memory/v2/harness/runner.ts

@@ -74,6 +74,12 @@ export async function runComparison(
     }
     turnsScored++;
 
+    // Thread the abort signal into the reconstructed input so retrievers that
+    // wrap LLM calls (e.g. the router retriever forwarding to `runRouter`) abort
+    // the in-flight per-turn call on caller disconnect — the loop gating below
+    // only stops scheduling new work, it can't cancel the current retrieval.
+    if (signal) reconstructed.input.signal = signal;
+
     const byRetriever: Record<string, TurnEval> = {};
     for (const retriever of retrievers) {
       if (signal?.aborted) break;

package/src/memory/v2/harness/trace.ts

@@ -41,6 +41,12 @@ export interface GateDecision {
   decision: "ready" | "more";
   /** When "more", the generated follow-up queries seeding the next pass. */
   questions?: string[];
+  /**
+   * The gate's one-line rationale for this verdict, when it supplied one.
+   * Surfaced in the descent trace and the live-shadow telemetry so a run can be
+   * analyzed after the fact ("why did the gate keep this set?").
+   */
+  reasoning?: string;
 }
 
 /** Everything that happened on one pass of the loop. */

package/src/memory/v2/migration.ts

@@ -337,9 +337,11 @@ export async function synthesizeConceptPage(
         `Synthesize a single concept page from these v1 sources. Slug hint: \`${cluster.slugHint}\`.\n\n${sourceListing}`,
       ),
     ],
-    [],
-    systemPrompt,
-    { config: { callSite: "memoryV2Migration" as const } },
+    {
+      tools: [],
+      systemPrompt,
+      config: { callSite: "memoryV2Migration" as const },
+    },
   );
   const body = extractText(response);
 

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

@@ -55,6 +55,11 @@ export interface PageIndexEntry {
   summary: string;
   /** Numeric IDs of outgoing edges, in sorted order. */
   edges: number[];
+  /**
+   * Leaf slugs declared in the page's `leaves:` frontmatter; `[]` when absent.
+   * Synthetic entries (skills, CLI commands) never declare leaves.
+   */
+  leaves: string[];
   /**
    * File mtime in epoch ms; 0 for synthetic entries (skills, CLI commands)
    * that have no on-disk source file. Used by `splitTier1` to rank pages
@@ -118,6 +123,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
     slug: string;
     summary: string;
     outgoingSlugs: string[];
+    leaves: string[];
     modifiedAt: number;
   }
 
@@ -177,6 +183,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug,
       summary: normalizeSummary(summarySource),
       outgoingSlugs: page.frontmatter.edges,
+      leaves: page.frontmatter.leaves ?? [],
       modifiedAt: mtimeMs,
     });
   }
@@ -186,6 +193,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug: `${SKILL_SLUG_PREFIX}${entry.id}`,
       summary: normalizeSummary(entry.content),
       outgoingSlugs: [],
+      leaves: [],
       modifiedAt: 0,
     });
   }
@@ -195,6 +203,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug: `${CLI_COMMAND_SLUG_PREFIX}${entry.id}`,
       summary: normalizeSummary(entry.description),
       outgoingSlugs: [],
+      leaves: [],
       modifiedAt: 0,
     });
   }
@@ -210,6 +219,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug: draft.slug,
       summary: draft.summary,
       edges: [],
+      leaves: draft.leaves,
       modifiedAt: draft.modifiedAt,
     };
     bySlug.set(entry.slug, entry);
@@ -329,6 +339,7 @@ function buildLocalPageIndex(
       slug: src.slug,
       summary: src.summary,
       edges: [],
+      leaves: src.leaves,
       modifiedAt: src.modifiedAt,
     };
     localBySlug.set(local.slug, local);

package/src/memory/v2/router.ts

@@ -453,19 +453,16 @@ async function runRouterBatch(
 
   let response;
   try {
-    response = await provider.sendMessage(
-      [userMsg],
-      [routerTool],
+    response = await provider.sendMessage([userMsg], {
+      tools: [routerTool],
       systemPrompt,
-      {
-        config: {
-          callSite: "memoryRouter" as const,
-          tool_choice: { type: "tool" as const, name: ROUTER_TOOL_NAME },
-          disableTurnStartCache: true,
-        },
-        ...(signal ? { signal } : {}),
+      config: {
+        callSite: "memoryRouter" as const,
+        tool_choice: { type: "tool" as const, name: ROUTER_TOOL_NAME },
+        disableTurnStartCache: true,
       },
-    );
+      ...(signal ? { signal } : {}),
+    });
   } catch (err) {
     log.warn({ err }, "Router provider call threw; treating as api_error");
     return emptyBatchResult("api_error");

package/src/memory/v2/sweep-job.ts

@@ -76,7 +76,7 @@ const MAX_BUFFER_CHARS = 16_000;
 // returns the tool input as `unknown`. The two must stay in sync.
 const SWEEP_TOOL_NAME = "emit_remember_entries";
 
-const SWEEP_TOOL: ToolDefinition = {
+const SWEEP_TOOL = {
   name: SWEEP_TOOL_NAME,
   description:
     "Emit zero or more remember()-style entries the assistant should commit to long-term memory.",
@@ -92,7 +92,7 @@ const SWEEP_TOOL: ToolDefinition = {
     },
     required: ["entries"],
   },
-};
+} satisfies ToolDefinition;
 
 const SweepResultSchema = z.object({
   entries: z.array(z.string()),
@@ -154,17 +154,14 @@ export async function memoryV2SweepJob(
       `## existingBuffer\n\n${existingBuffer || "(empty)"}\n\n` +
       `## recentMessages\n\n${recentText}`;
 
-    const response = await provider.sendMessage(
-      [userMessage(userText)],
-      [SWEEP_TOOL],
+    const response = await provider.sendMessage([userMessage(userText)], {
+      tools: [SWEEP_TOOL],
       systemPrompt,
-      {
-        config: {
-          callSite: "memoryV2Sweep" as const,
-          tool_choice: { type: "tool" as const, name: SWEEP_TOOL_NAME },
-        },
+      config: {
+        callSite: "memoryV2Sweep" as const,
+        tool_choice: { type: "tool" as const, name: SWEEP_TOOL_NAME },
       },
-    );
+    });
 
     const toolBlock = extractToolUse(response);
     if (!toolBlock || toolBlock.name !== SWEEP_TOOL_NAME) {

package/src/memory/v2/types.ts

@@ -40,6 +40,7 @@ export const ConceptPageFrontmatterSchema = z
     ref_files: z.array(z.string()).default([]),
     ref_urls: z.array(z.string().url()).default([]),
     summary: z.string().optional(),
+    leaves: z.array(z.string()).optional(),
   })
   .strict();
 

package/src/memory/v3/__tests__/assign.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Tests for the v3 page→leaf classifier. Uses a stub provider so no live LLM
+ * is hit. Pages are written into a temp workspace.
+ */
+
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolUseContent,
+} from "../../../providers/types.js";
+import { readPage, writePage } from "../../v2/page-store.js";
+import type { ConceptPageFrontmatter } from "../../v2/types.js";
+import type { LeafNode, LeafTree } from "../types.js";
+
+// Stub the provider layer before importing `assign.js` so its static import
+// chain (which transitively pulls in CES/credential workspace packages that
+// aren't built in a fresh worktree) never loads. The classifier is
+// provider-injectable, so every test passes its own stub provider — the real
+// `getConfiguredProvider` is never exercised here.
+mock.module("../../../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => null,
+  extractToolUse: (response: ProviderResponse) =>
+    response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
+  userMessage: (text: string): Message => ({
+    role: "user",
+    content: [{ type: "text", text }],
+  }),
+}));
+
+const { assignPages } = await import("../assign.js");
+
+function makeLeaf(path: string, description: string): LeafNode {
+  return {
+    path,
+    frontmatter: { path, in_core: false },
+    description,
+    members: [],
+    domain: path.split("/")[0],
+  };
+}
+
+function makeTree(leaves: LeafNode[]): LeafTree {
+  return {
+    leaves: new Map(leaves.map((l) => [l.path, l])),
+    byPage: new Map(),
+  };
+}
+
+/** Sorted by path: [1] domain-a/topic-x, [2] domain-a/topic-y, [3] domain-b/topic-z */
+function threeLeafTree(): LeafTree {
+  return makeTree([
+    makeLeaf("domain-b/topic-z", "about z"),
+    makeLeaf("domain-a/topic-x", "about x"),
+    makeLeaf("domain-a/topic-y", "about y"),
+  ]);
+}
+
+function stubProvider(
+  handler: (
+    messages: Message[],
+    options?: SendMessageOptions,
+  ) => ProviderResponse | Promise<ProviderResponse>,
+): Provider {
+  return {
+    name: "stub",
+    sendMessage: async (messages, options) => handler(messages, options),
+  } as Provider;
+}
+
+function response(content: ProviderResponse["content"]): ProviderResponse {
+  return {
+    content,
+    model: "stub-model",
+    stopReason: "tool_use",
+    usage: { inputTokens: 0, outputTokens: 0 },
+  };
+}
+
+function toolResponse(ids: unknown[]): ProviderResponse {
+  return response([
+    { type: "tool_use", id: "tu-1", name: "assign_leaves", input: { ids } },
+  ]);
+}
+
+function textResponse(text: string): ProviderResponse {
+  return response([{ type: "text", text }]);
+}
+
+let workspaceDir: string;
+
+beforeEach(async () => {
+  workspaceDir = await mkdtemp(join(tmpdir(), "v3-assign-"));
+});
+
+afterEach(async () => {
+  await rm(workspaceDir, { recursive: true, force: true });
+});
+
+async function makePage(
+  slug: string,
+  frontmatter: Partial<ConceptPageFrontmatter>,
+  body = "page body",
+): Promise<void> {
+  await writePage(workspaceDir, {
+    slug,
+    frontmatter: { edges: [], ref_files: [], ref_urls: [], ...frontmatter },
+    body,
+  });
+}
+
+describe("assignPages", () => {
+  test("unions classified picks with prior picks, never overwriting", async () => {
+    await makePage("page-a", { leaves: ["domain-a/topic-x"] });
+    // Classifier returns [2] -> domain-a/topic-y and [1] -> already present.
+    const provider = stubProvider(() => toolResponse([2, 1]));
+
+    const results = await assignPages({
+      tree: threeLeafTree(),
+      workspaceDir,
+      slugs: ["page-a"],
+      provider,
+      throttleMs: 0,
+    });
+
+    expect(results).toEqual([
+      {
+        slug: "page-a",
+        before: ["domain-a/topic-x"],
+        after: ["domain-a/topic-x", "domain-a/topic-y"],
+        failed: false,
+      },
+    ]);
+
+    const written = await readPage(workspaceDir, "page-a");
+    expect(written?.frontmatter.leaves).toEqual([
+      "domain-a/topic-x",
+      "domain-a/topic-y",
+    ]);
+  });
+
+  test("classification failure leaves the page's leaves unchanged", async () => {
+    await makePage("page-a", { leaves: ["domain-b/topic-z"] });
+
+    // (a) provider throws
+    const throwing = stubProvider(() => {
+      throw new Error("boom");
+    });
+    let results = await assignPages({
+      tree: threeLeafTree(),
+      workspaceDir,
+      slugs: ["page-a"],
+      provider: throwing,
+      throttleMs: 0,
+    });
+    expect(results[0]).toEqual({
+      slug: "page-a",
+      before: ["domain-b/topic-z"],
+      after: ["domain-b/topic-z"],
+      failed: true,
+    });
+    expect(
+      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
+    ).toEqual(["domain-b/topic-z"]);
+
+    // (b) no tool use
+    results = await assignPages({
+      tree: threeLeafTree(),
+      workspaceDir,
+      slugs: ["page-a"],
+      provider: stubProvider(() => textResponse("no tool here")),
+      throttleMs: 0,
+    });
+    expect(results[0].failed).toBe(true);
+    expect(
+      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
+    ).toEqual(["domain-b/topic-z"]);
+
+    // (c) empty ids
+    results = await assignPages({
+      tree: threeLeafTree(),
+      workspaceDir,
+      slugs: ["page-a"],
+      provider: stubProvider(() => toolResponse([])),
+      throttleMs: 0,
+    });
+    expect(results[0].failed).toBe(true);
+    expect(
+      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
+    ).toEqual(["domain-b/topic-z"]);
+  });
+
+  test("deterministic id->path mapping, dropping out-of-range and 0 ids", async () => {
+    await makePage("page-a", {});
+    // 0 and 99 are invalid; 3 -> domain-b/topic-z; 1 -> domain-a/topic-x.
+    const provider = stubProvider(() => toolResponse([0, 99, 3, 1, -1, 2.5]));
+
+    const results = await assignPages({
+      tree: threeLeafTree(),
+      workspaceDir,
+      slugs: ["page-a"],
+      provider,
+      throttleMs: 0,
+    });
+
+    expect(results[0].after).toEqual(["domain-b/topic-z", "domain-a/topic-x"]);
+    expect(results[0].failed).toBe(false);
+  });
+
+  test("defaults to pages with empty or missing leaves", async () => {
+    await makePage("page-empty", { leaves: [] });
+    await makePage("page-missing", {});
+    await makePage("page-classified", { leaves: ["domain-a/topic-x"] });
+
+    const seen: string[] = [];
+    const provider = stubProvider((messages) => {
+      const text = messages[0]?.content
+        .map((b) => (b.type === "text" ? b.text : ""))
+        .join("");
+      seen.push(text);
+      return toolResponse([2]);
+    });
+
+    const results = await assignPages({
+      tree: threeLeafTree(),
+      workspaceDir,
+      provider,
+      throttleMs: 0,
+    });
+
+    const slugs = results.map((r) => r.slug).sort();
+    expect(slugs).toEqual(["page-empty", "page-missing"]);
+    // The classified page was never sent to the provider.
+    expect(seen.length).toBe(2);
+  });
+});

package/src/memory/v3/__tests__/capabilities.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  CAPABILITIES_LEAF_PATH,
+  type CapabilityResolvers,
+  injectCapabilitiesLeaf,
+  isCapabilitySlug,
+  renderCapabilityContent,
+} from "../capabilities.js";
+import { buildNeedleIndex } from "../needle.js";
+import type { LeafPath, LeafTree, Slug } from "../types.js";
+
+function emptyTree(): LeafTree {
+  return { leaves: new Map(), byPage: new Map<Slug, LeafPath[]>() };
+}
+
+describe("isCapabilitySlug", () => {
+  test("true for skill and CLI-command slugs, false otherwise", () => {
+    expect(isCapabilitySlug("skills/meet-join")).toBe(true);
+    expect(isCapabilitySlug("cli-commands/schedules")).toBe(true);
+    expect(isCapabilitySlug("relationship/vows")).toBe(false);
+    expect(isCapabilitySlug("some-page")).toBe(false);
+  });
+});
+
+describe("injectCapabilitiesLeaf", () => {
+  test("registers an always-on leaf with the synthetic slugs as members", () => {
+    const tree = emptyTree();
+    const core = new Set<LeafPath>();
+    injectCapabilitiesLeaf(tree, core, ["skills/foo", "cli-commands/bar"]);
+
+    const leaf = tree.leaves.get(CAPABILITIES_LEAF_PATH);
+    expect(leaf?.frontmatter.in_core).toBe(true);
+    expect(leaf?.members).toEqual(["skills/foo", "cli-commands/bar"]);
+    expect(core.has(CAPABILITIES_LEAF_PATH)).toBe(true);
+  });
+
+  test("unions the leaf into each member's byPage entry without dropping existing leaves", () => {
+    const tree = emptyTree();
+    tree.byPage.set("skills/foo", ["other/leaf"]);
+    injectCapabilitiesLeaf(tree, new Set<LeafPath>(), [
+      "skills/foo",
+      "cli-commands/bar",
+    ]);
+
+    expect(tree.byPage.get("skills/foo")).toEqual([
+      "other/leaf",
+      CAPABILITIES_LEAF_PATH,
+    ]);
+    expect(tree.byPage.get("cli-commands/bar")).toEqual([
+      CAPABILITIES_LEAF_PATH,
+    ]);
+  });
+
+  test("is idempotent — re-injecting does not duplicate the byPage entry", () => {
+    const tree = emptyTree();
+    const core = new Set<LeafPath>();
+    injectCapabilitiesLeaf(tree, core, ["skills/foo"]);
+    injectCapabilitiesLeaf(tree, core, ["skills/foo"]);
+    expect(tree.byPage.get("skills/foo")).toEqual([CAPABILITIES_LEAF_PATH]);
+  });
+
+  test("stays always-on even with no installed skills/commands", () => {
+    const tree = emptyTree();
+    const core = new Set<LeafPath>();
+    injectCapabilitiesLeaf(tree, core, []);
+    expect(tree.leaves.get(CAPABILITIES_LEAF_PATH)?.members).toEqual([]);
+    expect(core.has(CAPABILITIES_LEAF_PATH)).toBe(true);
+  });
+});
+
+describe("renderCapabilityContent", () => {
+  const resolvers: CapabilityResolvers = {
+    skill: (slug) =>
+      slug === "skills/foo" ? { id: "foo", content: "foo capability" } : null,
+    cli: (slug) =>
+      slug === "cli-commands/bar"
+        ? { id: "bar", content: "bar capability" }
+        : null,
+  };
+
+  test("renders a skill slug with a Skill header", () => {
+    expect(renderCapabilityContent("skills/foo", resolvers)).toBe(
+      "# Skill: foo\nfoo capability",
+    );
+  });
+
+  test("renders a CLI-command slug with a CLI header", () => {
+    expect(renderCapabilityContent("cli-commands/bar", resolvers)).toBe(
+      "# CLI command: bar\nbar capability",
+    );
+  });
+
+  test("degrades to '' for a capability slug the cache cannot resolve", () => {
+    expect(renderCapabilityContent("skills/missing", resolvers)).toBe("");
+  });
+
+  test("returns null for a non-capability slug so the caller reads the on-disk page", () => {
+    expect(renderCapabilityContent("relationship/vows", resolvers)).toBeNull();
+  });
+});
+
+describe("needle indexes injected capability members", () => {
+  test("a skill slug is lexically retrievable by its title and summary", async () => {
+    const tree = emptyTree();
+    injectCapabilitiesLeaf(tree, new Set<LeafPath>(), ["skills/meet-join"]);
+
+    const needle = await buildNeedleIndex(
+      tree,
+      async () => "Join and transcribe a video meeting",
+    );
+
+    // By slug-derived title token.
+    expect(needle.query("meet", 5)).toContain("skills/meet-join");
+    // By summary token.
+    expect(needle.query("transcribe", 5)).toContain("skills/meet-join");
+  });
+});

package/src/memory/v3/__tests__/core.test.ts

@@ -0,0 +1,39 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { loadCore } from "../core.js";
+
+const BUNDLED_DATA_DIR = join(import.meta.dir, "..", "data");
+
+describe("loadCore", () => {
+  let tmpDirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      tmpDirs.map((d) => rm(d, { recursive: true, force: true })),
+    );
+    tmpDirs = [];
+  });
+
+  async function makeTmpDir(): Promise<string> {
+    const dir = await mkdtemp(join(tmpdir(), "v3-core-"));
+    tmpDirs.push(dir);
+    return dir;
+  }
+
+  test("loads alwaysOn from the supplied dataDir's core.json into a Set", async () => {
+    const core = await loadCore(BUNDLED_DATA_DIR);
+    expect(core).toBeInstanceOf(Set);
+    expect(core.has("domain-a/topic-x")).toBe(true);
+    expect(core.size).toBe(1);
+  });
+
+  test("returns empty set when core.json is missing", async () => {
+    const emptyDataDir = await makeTmpDir();
+    const core = await loadCore(emptyDataDir);
+    expect(core).toBeInstanceOf(Set);
+    expect(core.size).toBe(0);
+  });
+});

package/src/memory/v3/__tests__/fixtures/eval-turns.json

@@ -0,0 +1,36 @@
+{
+  "_comment": "Synthetic, generic eval turns for the memory-v3 orchestrator. No real content. Domains/slugs are placeholders (domain-a/topic-x, page-a). Each turn names which leaves L1 should open and which page IDs L2 should select per opened leaf; expectedFinalInjection is the orchestrator's deduped slug list for that turn given a SHARED working set across the sequence.",
+  "turns": [
+    {
+      "name": "turn 1 — open topic-x, select page-a (pinned) and page-b",
+      "currentMessage": "tell me about page a",
+      "routeIds": [1],
+      "leafSelections": {
+        "domain-a/topic-x": { "ids": [1, 2], "pinned_ids": [1] }
+      },
+      "expectedOpenedLeaves": ["domain-a/topic-x"],
+      "expectedFinalInjection": ["page-a", "page-b"]
+    },
+    {
+      "name": "turn 2 — open topic-y, select page-c; page-a carries forward (pinned)",
+      "currentMessage": "now about page c",
+      "routeIds": [2],
+      "leafSelections": {
+        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
+      },
+      "expectedOpenedLeaves": ["domain-a/topic-y"],
+      "expectedFinalInjection": ["page-c", "page-a", "page-b"]
+    },
+    {
+      "name": "turn 3 — open both leaves, select page-b and page-c",
+      "currentMessage": "compare page b and page c",
+      "routeIds": [1, 2],
+      "leafSelections": {
+        "domain-a/topic-x": { "ids": [2], "pinned_ids": [] },
+        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
+      },
+      "expectedOpenedLeaves": ["domain-a/topic-x", "domain-a/topic-y"],
+      "expectedFinalInjection": ["page-b", "page-c", "page-a"]
+    }
+  ]
+}