@vellumai/assistant 0.8.6 → 0.8.7

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"]
+    }
+  ]
+}

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

@@ -0,0 +1,37 @@
+{
+  "_comment": "Synthetic, generic turns for the memory-v3 LIVE-injection integration test. No real content. The tree has two leaves (domain-a/topic-x → [page-a, page-b], domain-a/topic-y → [page-c]); L1 id 1 → topic-x, id 2 → topic-y. Each turn names which leaves L1 opens and which page IDs L2 selects (and pins) per opened leaf. Driven through a SHARED WorkingSet across the sequence so carry-forward and window eviction are exercised end-to-end. The WorkingSet uses a small evictWindow so a non-pinned page selected only in turn 1 ages out by a later turn while a pinned page persists.",
+  "turns": [
+    {
+      "name": "turn 1 — open topic-x, select page-a (pinned) + page-b (unpinned)",
+      "currentMessage": "tell me about page a",
+      "routeIds": [1],
+      "leafSelections": {
+        "domain-a/topic-x": { "ids": [1, 2], "pinned_ids": [1] }
+      }
+    },
+    {
+      "name": "turn 2 — open topic-y, select page-c; page-a + page-b carry forward",
+      "currentMessage": "now about page c",
+      "routeIds": [2],
+      "leafSelections": {
+        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
+      }
+    },
+    {
+      "name": "turn 3 — open topic-y again, re-select page-c (refreshes its lastSeen)",
+      "currentMessage": "more on page c",
+      "routeIds": [2],
+      "leafSelections": {
+        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
+      }
+    },
+    {
+      "name": "turn 4 — open topic-y, re-select page-c; page-b now stale enough to age out",
+      "currentMessage": "still page c",
+      "routeIds": [2],
+      "leafSelections": {
+        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test";
+
+import { computeV3Health, renderV3Health } from "../health.js";
+import type { LeafNode, LeafPath, LeafTree, Slug } from "../types.js";
+
+/** Build an in-memory leaf node with the given members. */
+function leaf(path: LeafPath, members: Slug[]): LeafNode {
+  return {
+    path,
+    frontmatter: { path, in_core: false },
+    description: "",
+    members: [...members],
+    domain: path.split("/")[0],
+  };
+}
+
+/**
+ * Build a {@link LeafTree} from `{ leafPath: members[] }`. `byPage` is the
+ * inverted membership map, matching what `loadLeafTree` produces.
+ */
+function tree(spec: Record<LeafPath, Slug[]>): LeafTree {
+  const leaves = new Map<LeafPath, LeafNode>();
+  const byPage = new Map<Slug, LeafPath[]>();
+  for (const [path, members] of Object.entries(spec)) {
+    leaves.set(path, leaf(path, members));
+    for (const slug of members) {
+      const existing = byPage.get(slug);
+      if (existing) existing.push(path);
+      else byPage.set(slug, [path]);
+    }
+  }
+  return { leaves, byPage };
+}
+
+describe("computeV3Health", () => {
+  test("flags unassigned slugs (in neither byPage nor a leaf)", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b", "page-c"],
+    });
+    expect(report.unassigned).toEqual(["page-b", "page-c"]);
+  });
+
+  test("flags dangling page refs pointing at missing leaves", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b"],
+      pageRefs: new Map([
+        ["page-a", ["domain-a/topic-x"]],
+        ["page-b", ["domain-a/topic-missing"]],
+      ]),
+    });
+    expect(report.danglingRefs).toEqual([
+      { source: "page-b", leaf: "domain-a/topic-missing" },
+    ]);
+  });
+
+  test("flags dangling core refs", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a"],
+      core: new Set(["domain-a/topic-x", "domain-z/gone"]),
+    });
+    expect(report.danglingRefs).toEqual([
+      { source: "core", leaf: "domain-z/gone" },
+    ]);
+  });
+
+  test("groups unassigned slugs into novel clusters by 2-level prefix", () => {
+    const t = tree({ "domain-a/topic-x": ["assigned"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: [
+        "assigned",
+        "area-a/topic-x/one",
+        "area-a/topic-x/two",
+        "area-b/topic-y",
+      ],
+    });
+    expect(report.novelClusters).toEqual([
+      {
+        prefix: "area-a/topic-x",
+        slugs: ["area-a/topic-x/one", "area-a/topic-x/two"],
+        count: 2,
+      },
+      { prefix: "area-b/topic-y", slugs: ["area-b/topic-y"], count: 1 },
+    ]);
+  });
+
+  test("flags oversized leaves above 3x the median member count", () => {
+    // Medians: counts [1,1,1,12] -> sorted median = (1+1)/2 = 1; threshold 3.
+    const t = tree({
+      "domain-a/small-1": ["s1"],
+      "domain-a/small-2": ["s2"],
+      "domain-a/small-3": ["s3"],
+      "domain-a/big": Array.from({ length: 12 }, (_, i) => `b${i}`),
+    });
+    const report = computeV3Health({ tree: t, allSlugs: [] });
+    expect(report.oversizedLeaves).toEqual([
+      { leaf: "domain-a/big", members: 12 },
+    ]);
+  });
+
+  test("flags tiny leaves with 0-1 members", () => {
+    const t = tree({
+      "domain-a/empty": [],
+      "domain-a/single": ["s1"],
+      "domain-a/full": ["a", "b", "c"],
+    });
+    const report = computeV3Health({ tree: t, allSlugs: [] });
+    expect(report.tinyLeaves).toEqual([
+      { leaf: "domain-a/empty", members: 0 },
+      { leaf: "domain-a/single", members: 1 },
+    ]);
+  });
+
+  test("staleLabels is deferred (always empty)", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({ tree: t, allSlugs: ["page-a"] });
+    expect(report.staleLabels).toEqual([]);
+  });
+
+  test("passes lastMaintain through", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a"],
+      lastMaintain: { at: 12345, ok: true },
+    });
+    expect(report.lastMaintain).toEqual({ at: 12345, ok: true });
+  });
+
+  test("does not mutate inputs", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a", "page-b"] });
+    const allSlugs = ["page-a", "page-c"];
+    computeV3Health({ tree: t, allSlugs });
+    expect(allSlugs).toEqual(["page-a", "page-c"]);
+    expect(t.leaves.get("domain-a/topic-x")?.members).toEqual([
+      "page-a",
+      "page-b",
+    ]);
+  });
+});
+
+describe("renderV3Health", () => {
+  test("returns empty string when all-green", () => {
+    // A perfectly balanced tree: every leaf has the median count, no
+    // unassigned, no dangling, no clusters, lastMaintain ok.
+    const t = tree({
+      "domain-a/topic-x": ["page-a", "page-b"],
+      "domain-a/topic-y": ["page-c", "page-d"],
+    });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b", "page-c", "page-d"],
+      lastMaintain: { at: 1, ok: true },
+    });
+    expect(report.unassigned).toEqual([]);
+    expect(report.danglingRefs).toEqual([]);
+    expect(report.novelClusters).toEqual([]);
+    expect(report.oversizedLeaves).toEqual([]);
+    expect(report.tinyLeaves).toEqual([]);
+    expect(renderV3Health(report)).toBe("");
+  });
+
+  test("returns empty string when report is entirely empty and no maintain", () => {
+    const report = computeV3Health({
+      tree: { leaves: new Map(), byPage: new Map() },
+      allSlugs: [],
+    });
+    expect(renderV3Health(report)).toBe("");
+  });
+
+  test("renders a non-empty block when any signal fires", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b"],
+    });
+    const rendered = renderV3Health(report);
+    expect(rendered).not.toBe("");
+    expect(rendered).toContain("memory-v3 health:");
+    expect(rendered).toContain("unassigned");
+    expect(rendered).toContain("page-b");
+  });
+
+  test("renders a failed last-maintenance even with no other signals", () => {
+    const t = tree({
+      "domain-a/topic-x": ["page-a", "page-b"],
+      "domain-a/topic-y": ["page-c", "page-d"],
+    });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b", "page-c", "page-d"],
+      lastMaintain: { at: 99, ok: false },
+    });
+    const rendered = renderV3Health(report);
+    expect(rendered).toContain("last maintenance FAILED");
+  });
+});