@vellumai/assistant 0.7.3 → 0.8.1

package/src/memory/graph/graph-memory-state-store.ts

@@ -24,9 +24,7 @@ export function saveGraphMemoryState(
 /**
  * Load graph memory state for a conversation, or null if none exists.
  */
-export function loadGraphMemoryState(
-  conversationId: string,
-): string | null {
+export function loadGraphMemoryState(conversationId: string): string | null {
   const db = getDb();
   const row = db
     .select({ stateJson: conversationGraphMemoryState.stateJson })
@@ -35,3 +33,18 @@ export function loadGraphMemoryState(
     .get();
   return row?.stateJson ?? null;
 }
+
+/**
+ * Copy the parent conversation's graph memory state row to a new conversation
+ * id so the forked conversation resumes with the parent's InContextTracker
+ * snapshot (in-context node IDs, per-node turn log, current turn). No-op if
+ * the parent has no row yet.
+ */
+export function forkGraphMemoryState(
+  parentConversationId: string,
+  newConversationId: string,
+): void {
+  const stateJson = loadGraphMemoryState(parentConversationId);
+  if (stateJson == null) return;
+  saveGraphMemoryState(newConversationId, stateJson);
+}

package/src/memory/graph/graph-search.test.ts

@@ -1,12 +1,13 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
-import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
 
-// This test exercises the v1 graph search path. The `memory-v2-enabled` flag
-// (registry default `true`) makes graph-search short-circuit to keep traffic
-// off the legacy collection — disable it so the v1 path stays under test.
-_setOverridesForTesting({ "memory-v2-enabled": false });
+// This test exercises the v1 graph search path. `config.memory.v2.enabled`
+// (default `true`) makes graph-search short-circuit to keep traffic off
+// the legacy collection — force it off so the v1 path stays under test.
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: { v2: { enabled: false } } }),
+}));
 
 mock.module("../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),

package/src/memory/graph/graph-search.ts

@@ -5,7 +5,6 @@
 import { getConfig } from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { embedAndUpsert } from "../job-utils.js";
@@ -46,11 +45,11 @@ export async function searchGraphNodes(
   sparseVector?: QdrantSparseVector,
   dateRange?: { afterMs?: number; beforeMs?: number },
 ): Promise<GraphSearchResult[]> {
-  // v2 owns the read path when both gates are on. The v1 `memory` collection
-  // is in active retirement and a corrupted sparse segment can OOM-crash the
+  // v2 owns the read path when enabled. The v1 `memory` collection is in
+  // active retirement and a corrupted sparse segment can OOM-crash the
   // shared Qdrant process — short-circuiting here keeps v1 background work
   // and stale callers from taking v2 down with them.
-  if (isMemoryV2ReadActive(getConfig())) return [];
+  if (getConfig().memory.v2.enabled) return [];
 
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");

package/src/memory/graph/retriever.test.ts

@@ -71,7 +71,6 @@ mock.module("../../providers/provider-send-message.js", () => ({
   extractToolUse: () => null,
 }));
 
-import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { resetDb } from "../db-connection.js";
@@ -82,12 +81,16 @@ import { loadContextMemory, retrieveForTurn } from "./retriever.js";
 import { createNode } from "./store.js";
 import type { NewNode } from "./types.js";
 
-// These tests exercise v1 retrieval. v2 takeover (both `memory-v2-enabled`
-// flag *and* `memory.v2.enabled` schema field) makes `loadContextMemory`
-// short-circuit, so disable the flag here to keep the v1 path under test.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
-const TEST_CONFIG: AssistantConfig = { ...DEFAULT_CONFIG };
+// These tests exercise v1 retrieval. `memory.v2.enabled` (default `true`)
+// makes `loadContextMemory` short-circuit, so disable it here to keep the
+// v1 path under test.
+const TEST_CONFIG: AssistantConfig = {
+  ...DEFAULT_CONFIG,
+  memory: {
+    ...DEFAULT_CONFIG.memory,
+    v2: { ...DEFAULT_CONFIG.memory.v2, enabled: false },
+  },
+};
 
 function makeCapabilityNode(content: string, capId: string): NewNode {
   const now = Date.now();
@@ -407,8 +410,10 @@ describe("loadContextMemory — dual-query capability ranking", () => {
 
   // Build a config where capabilityReserve=1 so the ranking code actually
   // prunes (it only prunes when capabilityNodes.length > capabilityReserve).
+  // memory.v2.enabled=false to keep the v1 retrieval path under test.
   const DUAL_QUERY_CONFIG: AssistantConfig = structuredClone(DEFAULT_CONFIG);
   DUAL_QUERY_CONFIG.memory.retrieval.injection.contextLoad.capabilityReserve = 1;
+  DUAL_QUERY_CONFIG.memory.v2.enabled = false;
 
   // Keyword-routed embed: any text that contains a topic keyword returns a
   // one-hot vector identifying that topic. Anything else falls back to a

package/src/memory/graph/retriever.ts

@@ -14,7 +14,6 @@ import {
 } from "../../providers/provider-send-message.js";
 import type { ContentBlock, ImageContent } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { embedWithRetry } from "../embed.js";
 import {
   generateSparseEmbedding,
@@ -426,12 +425,12 @@ interface ContextLoadResult {
 export async function loadContextMemory(
   opts: ContextLoadOpts,
 ): Promise<ContextLoadResult> {
-  // v2 owns the read path when both gates are on. The v1 collection is in
-  // active retirement and querying it can OOM-crash Qdrant via a corrupted
-  // sparse segment, so we skip the embedding work and downstream searches
+  // v2 owns the read path when enabled. The v1 collection is in active
+  // retirement and querying it can OOM-crash Qdrant via a corrupted sparse
+  // segment, so we skip the embedding work and downstream searches
   // entirely. Caller (`runContextLoad`) sees zero nodes and routes to the
   // v2 activation pipeline.
-  if (isMemoryV2ReadActive(opts.config)) {
+  if (opts.config.memory.v2.enabled) {
     return {
       nodes: [],
       serendipityNodes: [],

package/src/memory/graph/tool-handlers.ts

@@ -2,14 +2,13 @@
 // Memory Tool handlers
 //
 // remember: save facts to the PKB (buffer.md + daily archive) under the v1
-// path, or to memory/buffer.md + memory/archive/<today>.md when the
-// `memory-v2-enabled` feature flag is on.
+// path, or to memory/buffer.md + memory/archive/<today>.md when memory v2 is
+// active.
 // ---------------------------------------------------------------------------
 
 import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -46,7 +45,7 @@ export function handleRemember(
   const now = new Date();
   const entry = formatRememberEntry(input.content.trim(), now);
 
-  if (isAssistantFeatureFlagEnabled("memory-v2-enabled", config)) {
+  if (config.memory.v2.enabled) {
     appendBufferAndArchive({
       rootDir: join(workspaceDir, "memory"),
       entry,
@@ -70,6 +69,22 @@ export function handleRemember(
   return { success: true, message: "Saved to knowledge base." };
 }
 
+/**
+ * Format `now` as a buffer-entry timestamp (`Mon D, h:mm AM/PM`). Exported so
+ * the memory v2 consolidation job can present its cutoff in the same shape
+ * the buffer entries use, making the agent's "timestamp ≥ cutoff" comparison
+ * unambiguous at minute precision.
+ */
+export function formatBufferTimestamp(now: Date): string {
+  const month = now.toLocaleString("en-US", { month: "short" });
+  const day = now.getDate();
+  const hours = now.getHours();
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const displayHour = hours % 12 || 12;
+  return `${month} ${day}, ${displayHour}:${minutes} ${ampm}`;
+}
+
 /**
  * Build a timestamped bullet entry for `buffer.md` / `archive/<date>.md`.
  *
@@ -81,13 +96,7 @@ export function handleRemember(
  * entries identically to user-facing `remember()` calls.
  */
 export function formatRememberEntry(content: string, now: Date): string {
-  const month = now.toLocaleString("en-US", { month: "short" });
-  const day = now.getDate();
-  const hours = now.getHours();
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const ampm = hours >= 12 ? "PM" : "AM";
-  const displayHour = hours % 12 || 12;
-  return `- [${month} ${day}, ${displayHour}:${minutes} ${ampm}] ${content}\n`;
+  return `- [${formatBufferTimestamp(now)}] ${content}\n`;
 }
 
 /**

package/src/memory/graph/tools.ts

@@ -2,6 +2,8 @@
 // Memory Tool definitions for agentic recall and remember.
 // ---------------------------------------------------------------------------
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../../config/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import {
   ALL_RECALL_SOURCES,
@@ -12,13 +14,13 @@ import {
 const RECALL_DEPTHS = ["fast", "standard", "deep"] as const;
 
 /**
- * Explicit local information search across memory, PKB, conversations, and
+ * Explicit local information search across memory, conversations, and
  * workspace files.
  */
 export const graphRecallDefinition: ToolDefinition = {
   name: "recall",
   description:
-    'Search local information the moment you feel uncertain. Use recall for memory, the personal knowledge base, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
+    'Search local information the moment you feel uncertain. Use recall for memory, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
   input_schema: {
     type: "object",
     properties: {
@@ -34,7 +36,7 @@ export const graphRecallDefinition: ToolDefinition = {
           enum: [...ALL_RECALL_SOURCES],
         },
         description:
-          "Optional local sources to search. Omit to search memory, PKB, conversations, and workspace files.",
+          "Optional local sources to search. Omit to search memory, conversations, and workspace files.",
       },
       max_results: {
         type: "integer",
@@ -53,18 +55,55 @@ export const graphRecallDefinition: ToolDefinition = {
   },
 };
 
+/**
+ * Default (high-pressure) `remember` tool description. Used when the
+ * `memory-retrospective` feature flag is OFF. The volume-shaming language
+ * ("almost every turn", "most frequently used tool") drives aggressive
+ * in-conversation capture for users who don't have the retrospective
+ * backstop enabled.
+ */
+const REMEMBER_DESCRIPTION_DEFAULT =
+  "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.";
+
+/**
+ * Relaxed `remember` tool description used when `memory-retrospective` is
+ * ON. The retrospective pass catches what isn't captured in the moment, so
+ * the in-conversation pressure eases to a judgment framing: pause when
+ * something feels worth marking, not because the volume is required.
+ */
+const REMEMBER_DESCRIPTION_RELAXED =
+  "Remember anything concrete the user shared: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
+
+/**
+ * Return the description that should appear in the `remember` tool
+ * registration for the current config. The variant is selected by the
+ * `memory-retrospective` assistant feature flag. Exposed as a function so
+ * the tool registrar can compute the value at registration time without
+ * importing config layers into the static definition.
+ */
+export function getRememberDescription(config: AssistantConfig): string {
+  return isAssistantFeatureFlagEnabled("memory-retrospective", config)
+    ? REMEMBER_DESCRIPTION_RELAXED
+    : REMEMBER_DESCRIPTION_DEFAULT;
+}
+
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
  * `buffer.md` (immediately available in the next conversation) and the daily
- * archive (permanent date-indexed record). With the `memory-v2-enabled`
- * feature flag on, writes go under `memory/`; otherwise they go under
- * `pkb/`. Consolidation of the buffer into longer-form storage runs as a
- * separate periodic job in both modes.
+ * archive (permanent date-indexed record). When `memory.v2.enabled` is true,
+ * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
+ * of the buffer into longer-form storage runs as a separate periodic job in
+ * both modes.
+ *
+ * The static `description` field carries the default (high-pressure) text
+ * so any direct importer that doesn't go through `getRememberDescription`
+ * still gets a valid tool definition. The registered `RememberTool` in
+ * `tools/memory/register.ts` overrides this at registration time with the
+ * flag-aware variant.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
-  description:
-    "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.",
+  description: REMEMBER_DESCRIPTION_DEFAULT,
   input_schema: {
     type: "object",
     properties: {

package/src/memory/indexer.ts

@@ -9,10 +9,11 @@ import { getLogger } from "../util/logger.js";
 import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
-import { isMemoryV2ReadActive } from "./context-search/sources/memory-v2.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
+import { isMemoryRetrospectiveConversation } from "./memory-retrospective-enqueue.js";
+import { maybeEnqueueRetrospective } from "./memory-retrospective-trigger-check.js";
 import {
   extractMediaBlockMeta,
   extractTextFromStoredMessageContent,
@@ -190,7 +191,7 @@ export async function indexMessageNow(
       }
 
       const v2Config =
-        triggerConfig != null && isMemoryV2ReadActive(triggerConfig)
+        triggerConfig != null && triggerConfig.memory.v2.enabled
           ? triggerConfig
           : null;
 
@@ -284,6 +285,21 @@ export async function indexMessageNow(
           });
         }
       }
+
+      // ── Memory retrospective triggers ─────────────────────────────────
+      // Independent of auto-analyze: the retrospective is a focused,
+      // memory-only pass that re-reads messages since its last successful
+      // run and saves what the in-conversation `remember` calls didn't
+      // capture. Triggers (interval / message_count) are evaluated by
+      // `maybeEnqueueRetrospective`, which also enforces the per-conversation
+      // cooldown gate against retry storms. Recursion guard skips the
+      // memory-retrospective background conversation itself.
+      if (
+        triggerConfig != null &&
+        !isMemoryRetrospectiveConversation(input.conversationId)
+      ) {
+        maybeEnqueueRetrospective(input.conversationId, triggerConfig);
+      }
     }
 
     // ── Conversation summarization (independent of extraction) ────────

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -86,6 +86,10 @@ const upsertCalls: Array<{
   slug: string;
   dense: number[];
   sparse: { indices: number[]; values: number[] };
+  summary?: {
+    dense: number[];
+    sparse: { indices: number[]; values: number[] };
+  };
   updatedAt: number;
 }> = [];
 
@@ -96,6 +100,10 @@ mock.module("../../v2/qdrant.js", () => ({
     slug: string;
     dense: number[];
     sparse: { indices: number[]; values: number[] };
+    summary?: {
+      dense: number[];
+      sparse: { indices: number[]; values: number[] };
+    };
     updatedAt: number;
   }) => {
     upsertCalls.push(params);
@@ -195,7 +203,7 @@ describe("embedConceptPageJob — happy path", () => {
   test("reads the page, embeds it, and upserts to the v2 collection", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Alice prefers VS Code over Vim.\nShe ships at end of day.\n",
     });
 
@@ -223,7 +231,7 @@ describe("embedConceptPageJob — happy path", () => {
   test("populates the SQLite embedding cache row keyed on (concept_page, slug)", async () => {
     await writePage(tmpWorkspace, {
       slug: "bob-uses-zsh",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Bob uses zsh.\n",
     });
 
@@ -242,11 +250,117 @@ describe("embedConceptPageJob — happy path", () => {
   });
 });
 
+describe("embedConceptPageJob — summary embedding", () => {
+  test("embeds the summary when present and forwards summary vectors to upsert", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "summarized-page",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        summary: "A short prose summary that retrieval indexes separately.",
+      },
+      body: "Long-form body content.\n",
+    });
+
+    await embedConceptPageJob(
+      makeJob({ slug: "summarized-page" }),
+      TEST_CONFIG,
+    );
+
+    // Body and summary are batched into one backend call (saves a round-trip).
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0];
+    expect(call.slug).toBe("summarized-page");
+    expect(call.dense).toEqual([0.1, 0.2, 0.3, 0.4]);
+    expect(call.sparse).toBeDefined();
+    expect(call.summary?.dense).toEqual([0.1, 0.2, 0.3, 0.4]);
+    expect(call.summary?.sparse).toBeDefined();
+  });
+
+  test("skips summary embedding when the page has no summary in frontmatter", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "legacy-page",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Body only — no summary in frontmatter.\n",
+    });
+
+    await embedConceptPageJob(makeJob({ slug: "legacy-page" }), TEST_CONFIG);
+
+    // Only the body was embedded.
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0];
+    expect(call.summary).toBeUndefined();
+  });
+
+  test("skips summary embedding when the summary is whitespace-only", async () => {
+    // Whitespace-only summaries (` `, `\n`) are equivalent to absent — the
+    // embedding backend would reject the empty input downstream anyway.
+    await writePage(tmpWorkspace, {
+      slug: "whitespace-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        summary: "   ",
+      },
+      body: "Body content.\n",
+    });
+
+    await embedConceptPageJob(
+      makeJob({ slug: "whitespace-summary" }),
+      TEST_CONFIG,
+    );
+
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(upsertCalls[0].summary).toBeUndefined();
+  });
+
+  test("body and summary cache rows are independent (summary edit doesn't invalidate body)", async () => {
+    // Write a page with a summary, run the job to prime caches.
+    await writePage(tmpWorkspace, {
+      slug: "cached-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        summary: "First version of the summary.",
+      },
+      body: "Stable body that never changes.\n",
+    });
+    await embedConceptPageJob(makeJob({ slug: "cached-summary" }), TEST_CONFIG);
+    // Body + summary batched into a single backend call on first run.
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
+
+    // Edit only the summary — body stays identical, only the summary text
+    // changes. Re-running the job should hit the body cache (no re-embed)
+    // but recompute the summary embedding.
+    await writePage(tmpWorkspace, {
+      slug: "cached-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        summary: "Second version of the summary, different wording.",
+      },
+      body: "Stable body that never changes.\n",
+    });
+    await embedConceptPageJob(makeJob({ slug: "cached-summary" }), TEST_CONFIG);
+    // One additional backend call with only the summary text — body hit the cache.
+    expect(embedWithBackendCalls).toHaveLength(2);
+    expect(embedWithBackendCalls[1].inputs).toHaveLength(1);
+  });
+});
+
 describe("embedConceptPageJob — cache hit", () => {
   test("reuses the cached dense vector when content hash matches", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Stable content.\n",
     });
 
@@ -271,7 +385,7 @@ describe("embedConceptPageJob — cache hit", () => {
   test("re-embeds when the body changes (content hash mismatch)", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "First content.\n",
     });
     await embedConceptPageJob(
@@ -282,7 +396,7 @@ describe("embedConceptPageJob — cache hit", () => {
     // Rewrite with different body.
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Second content (different).\n",
     });
     await embedConceptPageJob(
@@ -337,7 +451,7 @@ describe("enqueueEmbedConceptPageJob", () => {
   test("round-trip: enqueued job dispatches through embedConceptPageJob", async () => {
     await writePage(tmpWorkspace, {
       slug: "round-trip-slug",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Round-trip body.\n",
     });