@vellumai/assistant 0.8.6 → 0.8.7

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -105,6 +105,43 @@ mock.module("../../jobs-store.js", () => ({
   isMemoryEnabled: () => true,
 }));
 
+// ── v3 health-injection mocks ───────────────────────────────────────
+//
+// The consolidation handler optionally prepends a v3 health block to the
+// prompt when a v3 flag is on AND the rendered report is non-empty. These
+// mocks let each test (a) toggle the flag, (b) decide what health block the
+// renderer produces, and (c) force the health computation to throw — without
+// materializing a real v3 data dir. The tree/core/page-index loaders are
+// stubbed to inert values; `computeV3Health` is a pass-through whose result is
+// fed to the toggleable `renderV3Health`.
+let v3FlagOn = false;
+mock.module("../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => v3FlagOn,
+}));
+
+let renderedHealth = "";
+let computeThrows = false;
+mock.module("../../v3/health.js", () => ({
+  computeV3Health: () => {
+    if (computeThrows) throw new Error("simulated health compute failure");
+    return {};
+  },
+  renderV3Health: () => renderedHealth,
+}));
+
+mock.module("../../v3/tree.js", () => ({
+  loadLeafTree: async () => ({ leaves: new Map(), byPage: new Map() }),
+  resolveDataDir: () => "/tmp/v3-data-stub",
+}));
+
+mock.module("../../v3/core.js", () => ({
+  loadCore: async () => new Set<string>(),
+}));
+
+mock.module("../../v2/page-index.js", () => ({
+  getPageIndex: async () => ({ entries: [] }),
+}));
+
 // ── Workspace pin ───────────────────────────────────────────────────
 let tmpWorkspace: string;
 let previousWorkspaceEnv: string | undefined;
@@ -173,6 +210,11 @@ beforeEach(() => {
   emitCalls.length = 0;
   enqueuedJobs.length = 0;
   nextJobIdCounter = 0;
+
+  // v3 health injection defaults: flag off, no rendered block, no throw.
+  v3FlagOn = false;
+  renderedHealth = "";
+  computeThrows = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -305,6 +347,25 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     expect(existsSync(lockPath())).toBe(false);
   });
 
+  test("enqueues memory_v3_maintain as a follow-up when a v3 flag is on", async () => {
+    v3FlagOn = true;
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    expect(enqueuedJobs.map((j) => j.type)).toEqual([
+      "memory_v2_reembed",
+      "memory_v3_maintain",
+    ]);
+  });
+
+  test("does not enqueue memory_v3_maintain when v3 flags are off", async () => {
+    v3FlagOn = false;
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
+  });
+
   test("returns run_failed and skips follow-ups when the runner reports failure", async () => {
     runnerImpl = async () => ({
       conversationId: "conv-1",
@@ -348,6 +409,69 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
   });
 });
 
+describe("memoryV2ConsolidateJob — v3 health injection", () => {
+  beforeEach(() => {
+    writeFileSync(
+      bufferPath(),
+      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n",
+    );
+  });
+
+  test("prepends the health block when a v3 flag is on and the report is actionable", async () => {
+    v3FlagOn = true;
+    renderedHealth = "memory-v3 health:\n- 2 unassigned slug(s): a, b";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    // The health block is PREPENDED, separated by a blank line, with the
+    // base consolidation prompt still present underneath it.
+    expect(prompt.startsWith(`${renderedHealth}\n\n`)).toBe(true);
+    expect(prompt).toContain("memory consolidation");
+    expect(prompt).not.toContain(CUTOFF_PLACEHOLDER);
+  });
+
+  test("leaves the prompt unchanged when the report is all-green (empty render)", async () => {
+    v3FlagOn = true;
+    renderedHealth = "";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).not.toContain("memory-v3 health:");
+    // Prompt is exactly the resolved consolidation body.
+    expect(prompt).toContain("memory consolidation");
+  });
+
+  test("leaves the prompt unchanged when v3 flags are off even if a block would render", async () => {
+    v3FlagOn = false;
+    renderedHealth = "memory-v3 health:\n- 1 unassigned slug(s): a";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).not.toContain("memory-v3 health:");
+    expect(prompt).toContain("memory consolidation");
+  });
+
+  test("falls back to the base prompt when health computation throws", async () => {
+    v3FlagOn = true;
+    computeThrows = true;
+    renderedHealth = "memory-v3 health:\n- should not appear";
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    // A health-compute failure must NEVER break consolidation.
+    expect(result.kind).toBe("invoked");
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).not.toContain("memory-v3 health:");
+    expect(prompt).toContain("memory consolidation");
+  });
+});
+
 describe("memoryV2ConsolidateJob — concurrent invocations", () => {
   beforeEach(() => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");

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

@@ -26,7 +26,12 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../../__tests__/helpers/mock-logger.js";
-import type { Provider, ProviderResponse } from "../../../providers/types.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../../../providers/types.js";
 
 // -- Mocks that must be installed before importing the module under test ---
 //
@@ -416,8 +421,11 @@ describe("synthesizeConceptPage", () => {
     let capturedSystem: string | undefined;
     const provider: Provider = {
       name: "stub",
-      sendMessage: async (_messages, _tools, system) => {
-        capturedSystem = system;
+      sendMessage: async (
+        _messages: Message[],
+        options?: SendMessageOptions,
+      ) => {
+        capturedSystem = options?.systemPrompt;
         return {
           content: [{ type: "text", text: "synthesized" }],
           model: "stub-model",

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

@@ -76,7 +76,12 @@ afterEach(() => {
 
 function makePage(
   slug: string,
-  opts: { edges?: string[]; summary?: string; body?: string } = {},
+  opts: {
+    edges?: string[];
+    summary?: string;
+    body?: string;
+    leaves?: string[];
+  } = {},
 ): ConceptPage {
   return {
     slug,
@@ -85,6 +90,7 @@ function makePage(
       ref_files: [],
       ref_urls: [],
       ...(opts.summary !== undefined ? { summary: opts.summary } : {}),
+      ...(opts.leaves !== undefined ? { leaves: opts.leaves } : {}),
     },
     body: opts.body ?? "",
   };
@@ -230,6 +236,36 @@ describe("getPageIndex", () => {
     expect(alice.edges).toEqual([bob.id]);
   });
 
+  test("exposes frontmatter leaves in the index entry", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("alice", {
+        summary: "A",
+        leaves: ["page-a", "domain-a/topic-x"],
+      }),
+    );
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("alice")?.leaves).toEqual([
+      "page-a",
+      "domain-a/topic-x",
+    ]);
+  });
+
+  test("defaults leaves to an empty array when the field is absent", async () => {
+    await writePage(workspaceDir, makePage("alice", { summary: "A" }));
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("alice")?.leaves).toEqual([]);
+  });
+
+  test("seeded skill entries carry an empty leaves list", async () => {
+    skillState.entries = [{ id: "browser", content: "Drive a browser." }];
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("skills/browser")?.leaves).toEqual([]);
+  });
+
   test("falls back to body when frontmatter.summary is absent", async () => {
     await writePage(
       workspaceDir,

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

@@ -148,8 +148,13 @@ afterEach(() => {
 function makeProvider(response: ProviderResponse): Provider {
   return {
     name: "stub",
-    sendMessage: async (messages, tools, systemPrompt, options) => {
-      providerCalls.push({ messages, tools, systemPrompt, options });
+    sendMessage: async (messages, options) => {
+      providerCalls.push({
+        messages,
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+        options,
+      });
       // Honor abort like a real provider would — if the signal already
       // aborted, throw the canonical AbortError so callers can assert that
       // signal forwarding actually has teeth.
@@ -752,9 +757,14 @@ describe("runRouter — batched (batch_size set)", () => {
     let callCount = 0;
     providerStub = {
       name: "partial-failure",
-      sendMessage: async (messages, tools, systemPrompt, options) => {
+      sendMessage: async (messages, options) => {
         callCount += 1;
-        providerCalls.push({ messages, tools, systemPrompt, options });
+        providerCalls.push({
+          messages,
+          tools: options?.tools,
+          systemPrompt: options?.systemPrompt,
+          options,
+        });
         if (callCount === 1) throw new Error("batch 1 boom");
         return toolUseResponse([1]);
       },

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

@@ -35,8 +35,10 @@ import {
 
 import { makeMockLogger } from "../../../__tests__/helpers/mock-logger.js";
 import type {
+  Message,
   Provider,
   ProviderResponse,
+  SendMessageOptions,
   ToolUseContent,
 } from "../../../providers/types.js";
 
@@ -100,9 +102,8 @@ afterAll(() => {
 });
 
 const { getDb } = await import("../../db-connection.js");
-const { resetDbForTesting } = await import(
-  "../../../__tests__/db-test-helpers.js"
-);
+const { resetDbForTesting } =
+  await import("../../../__tests__/db-test-helpers.js");
 const { initializeDb } = await import("../../db-init.js");
 const { messages, conversations } = await import("../../schema.js");
 const { memoryV2SweepJob } = await import("../sweep-job.js");
@@ -144,9 +145,9 @@ function makeJob(): Parameters<typeof memoryV2SweepJob>[0] {
 function makeEntriesProvider(entries: string[]): Provider {
   return {
     name: "stub",
-    sendMessage: async (msgs, _tools, systemPrompt) => {
+    sendMessage: async (msgs: Message[], options?: SendMessageOptions) => {
       providerCalls.push({
-        systemPrompt,
+        systemPrompt: options?.systemPrompt,
         userText: extractFirstUserText(msgs),
       });
       return {

package/src/memory/v2/backfill-jobs.ts

@@ -157,8 +157,14 @@ export async function memoryV2ActivationRecomputeJob(
   const workspaceDir = getWorkspaceDir();
   const database = getDb();
 
+  // Activation maps still need to refresh for archived conversations — a
+  // consolidated page can leave stale slugs above epsilon in their persisted
+  // state — so this job opts back into seeing archived rows.
   const conversations = listConversations(
     ACTIVATION_RECOMPUTE_CONVERSATION_LIMIT,
+    "standard",
+    0,
+    "all",
   );
   const edgeIndex = await getEdgeIndex(workspaceDir);
   const nowText = await loadNowText(workspaceDir);

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

@@ -61,6 +61,7 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { runBackgroundJob } from "../../runtime/background-job-runner.js";
 import { getLogger } from "../../util/logger.js";
@@ -72,6 +73,11 @@ import {
   type MemoryJob,
   type MemoryJobType,
 } from "../jobs-store.js";
+import { getPageIndex } from "../v2/page-index.js";
+import { loadCore } from "../v3/core.js";
+import { computeV3Health, renderV3Health } from "../v3/health.js";
+import { loadLeafTree, resolveDataDir } from "../v3/tree.js";
+import type { LeafPath, Slug } from "../v3/types.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "./constants.js";
 import { resolveConsolidationPrompt } from "./prompts/consolidation.js";
 
@@ -80,6 +86,14 @@ const log = getLogger("memory-v2-consolidate");
 /** Stable identifier surfaced in `runBackgroundJob` logs and notifications. */
 const JOB_NAME = "memory.consolidate";
 
+/**
+ * v3 plugin flags. Either being on (a) prepends a v3 health block to the
+ * consolidation prompt and (b) enqueues `memory_v3_maintain` as a
+ * post-consolidation follow-up. These gate the v3 plugin itself.
+ */
+const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
+const MEMORY_V3_LIVE = "memory-v3-live" as const;
+
 /**
  * Hard timeout for the consolidation run. Consolidation reads the buffer,
  * rewrites several files, and re-encodes essentials/threads — generous
@@ -95,9 +109,10 @@ const CONSOLIDATION_TIMEOUT_MS = 15 * 60 * 1000;
  * agent touched: mtime-diffing is fragile across filesystems, and the
  * embedder's content-hash cache makes unchanged pages effectively free.
  */
-const FOLLOW_UP_JOB_TYPES: readonly MemoryJobType[] = [
-  "memory_v2_reembed",
-] as const;
+const FOLLOW_UP_JOB_TYPES: readonly MemoryJobType[] = ["memory_v2_reembed"];
+
+/** Follow-up enqueued only when a v3 flag is on. */
+const V3_FOLLOW_UP_JOB_TYPE: MemoryJobType = "memory_v3_maintain";
 
 /**
  * Job handler. See file header for the full lifecycle. Returns a discriminated
@@ -167,13 +182,20 @@ export async function memoryV2ConsolidateJob(
     // it to a regular file under 1 MiB before substitution so a stray path
     // (or a `/dev/zero`-style pseudo-file) cannot exfiltrate megabytes of
     // bytes through the wake hint.
+    //
+    // That resolved prompt is the base; `maybePrependV3Health` prepends a
+    // freshly computed v3 health block when a v3 flag is on and the tree has
+    // actionable drift, leaving it untouched otherwise.
+    const basePrompt = resolveConsolidationPrompt(
+      config.memory.v2.consolidation_prompt_path,
+      cutoff,
+    );
+    const prompt = await maybePrependV3Health(basePrompt, config);
+
     const runResult = await runBackgroundJob({
       jobName: JOB_NAME,
       source: MEMORY_V2_CONSOLIDATION_SOURCE,
-      prompt: resolveConsolidationPrompt(
-        config.memory.v2.consolidation_prompt_path,
-        cutoff,
-      ),
+      prompt,
       trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
       callSite: "mainAgent",
       timeoutMs: CONSOLIDATION_TIMEOUT_MS,
@@ -197,9 +219,17 @@ export async function memoryV2ConsolidateJob(
 
     // Step 5: enqueue follow-up jobs. Enqueueing now keeps the dispatch
     // wiring exercised end-to-end so PR 21 only has to swap in the handler
-    // bodies.
+    // bodies. v3 maintenance is appended only while a v3 path (shadow or live)
+    // is active, so it never fans out on v2-only installs.
     const followUpJobIds: string[] = [];
-    for (const jobType of FOLLOW_UP_JOB_TYPES) {
+    const jobTypes: MemoryJobType[] = [...FOLLOW_UP_JOB_TYPES];
+    if (
+      isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
+      isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config)
+    ) {
+      jobTypes.push(V3_FOLLOW_UP_JOB_TYPE);
+    }
+    for (const jobType of jobTypes) {
       try {
         followUpJobIds.push(enqueueMemoryJob(jobType, {}));
       } catch (err) {
@@ -231,6 +261,56 @@ export async function memoryV2ConsolidateJob(
   }
 }
 
+/**
+ * When a v3 flag is enabled and the v3 tree has actionable structural drift,
+ * prepend a rendered health block to `basePrompt` so the consolidation run can
+ * fold tree maintenance into its pass. Returns `basePrompt` UNCHANGED when:
+ *   - neither `memory-v3-shadow` nor `memory-v3-live` is enabled,
+ *   - the health report is all-green (`renderV3Health` returns ""), or
+ *   - computing the report throws for any reason.
+ *
+ * The block is computed here (not baked into the prompt template) so an
+ * operator's custom consolidation prompt stays untouched and the block reflects
+ * the tree state at run time. Health computation is wrapped so a load/compute
+ * failure can never break consolidation — the run proceeds on the base prompt.
+ */
+async function maybePrependV3Health(
+  basePrompt: string,
+  config: AssistantConfig,
+): Promise<string> {
+  const v3Enabled =
+    isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
+    isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
+  if (!v3Enabled) return basePrompt;
+
+  try {
+    const pageIndex = await getPageIndex(getWorkspaceDir());
+    const pageLeaves = new Map<Slug, LeafPath[]>();
+    const allSlugs: Slug[] = [];
+    for (const entry of pageIndex.entries) {
+      pageLeaves.set(entry.slug, entry.leaves);
+      allSlugs.push(entry.slug);
+    }
+
+    const dataDir = resolveDataDir();
+    const [tree, core] = await Promise.all([
+      loadLeafTree(dataDir, pageLeaves),
+      loadCore(dataDir),
+    ]);
+
+    const report = computeV3Health({ tree, allSlugs, core });
+    const healthBlock = renderV3Health(report);
+    if (healthBlock.length === 0) return basePrompt;
+    return `${healthBlock}\n\n${basePrompt}`;
+  } catch (err) {
+    log.warn(
+      { err: err instanceof Error ? err.message : String(err) },
+      "consolidation: v3 health computation failed; using base prompt",
+    );
+    return basePrompt;
+  }
+}
+
 /**
  * Read `memory/buffer.md`. Missing file → empty string so the skip-on-empty
  * branch doesn't have to distinguish "no file" from "blank file".

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();