@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/plugins/defaults/memory/graph/__tests__/conversation-graph-memory-recent-summaries.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Tests for `ConversationGraphMemory.fetchRecentSummaries`. It pages through
+ * candidate conversation summaries most-recent first, resolves each
+ * conversation's type with a separate lookup rather than a JOIN (so the two
+ * tables need not share a connection), and partitions in JS: up to 3 user
+ * summaries (most recent first), then at most 1 background/scheduled to fill. It
+ * excludes the current conversation and any summary whose conversation row is
+ * gone.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getDb,
+  getMemoryDb,
+} from "../../../../../persistence/db-connection.js";
+import { initializeDb } from "../../../../../persistence/db-init.js";
+import {
+  conversations,
+  memorySummaries,
+} from "../../../../../persistence/schema/index.js";
+import { ConversationGraphMemory } from "../conversation-graph-memory.js";
+
+await initializeDb();
+
+const CURRENT = "conv-current";
+
+function seedConversation(id: string, type: string): void {
+  getDb()
+    .insert(conversations)
+    .values({ id, conversationType: type, createdAt: 0, updatedAt: 0 })
+    .run();
+}
+
+function seedSummary(
+  scopeKey: string,
+  summary: string,
+  updatedAt: number,
+): void {
+  getMemoryDb()!
+    .insert(memorySummaries)
+    .values({
+      id: `sum-${scopeKey}`,
+      scope: "conversation",
+      scopeKey,
+      summary,
+      tokenEstimate: 10,
+      version: 1,
+      startAt: 0,
+      endAt: updatedAt,
+      createdAt: updatedAt,
+      updatedAt,
+    })
+    .run();
+}
+
+function recentSummaries(): string[] {
+  const cgm = new ConversationGraphMemory(CURRENT);
+  return (
+    cgm as unknown as { fetchRecentSummaries: () => string[] }
+  ).fetchRecentSummaries();
+}
+
+beforeEach(() => {
+  getMemoryDb()!.delete(memorySummaries).run();
+  getDb().delete(conversations).run();
+});
+
+describe("fetchRecentSummaries", () => {
+  test("returns the 3 most-recent user summaries and no background when 3+ users exist", () => {
+    ["u1", "u2", "u3", "u4"].forEach((id, i) => {
+      seedConversation(id, "standard");
+      seedSummary(id, `user ${id}`, 100 + i); // u4 is newest at 103
+    });
+    // A background summary that is newer than every user summary must still be
+    // dropped once 3 user summaries are available.
+    seedConversation("b1", "background");
+    seedSummary("b1", "bg b1", 1000);
+
+    expect(recentSummaries()).toEqual(["user u4", "user u3", "user u2"]);
+  });
+
+  test("fills the remaining slot with the single most-recent background when fewer than 3 users", () => {
+    seedConversation("u1", "standard");
+    seedSummary("u1", "user u1", 200);
+    seedConversation("u2", "standard");
+    seedSummary("u2", "user u2", 100);
+    seedConversation("b1", "background");
+    seedSummary("b1", "bg b1", 300); // newest overall
+    seedConversation("b2", "scheduled");
+    seedSummary("b2", "bg b2", 250);
+
+    expect(recentSummaries()).toEqual(["user u1", "user u2", "bg b1"]);
+  });
+
+  test("returns a single background summary when there are no user summaries", () => {
+    seedConversation("b1", "background");
+    seedSummary("b1", "bg b1", 100);
+    seedConversation("b2", "scheduled");
+    seedSummary("b2", "bg b2", 200); // newest
+
+    expect(recentSummaries()).toEqual(["bg b2"]);
+  });
+
+  test("excludes the current conversation and orphan summaries", () => {
+    seedSummary(CURRENT, "self summary", 500); // excluded: current conversation
+    seedSummary("orphan", "orphan summary", 400); // excluded: no conversation row
+    seedConversation("u1", "standard");
+    seedSummary("u1", "user u1", 100);
+
+    expect(recentSummaries()).toEqual(["user u1"]);
+  });
+
+  test("orders results most-recent first by updatedAt", () => {
+    seedConversation("a", "standard");
+    seedSummary("a", "older", 100);
+    seedConversation("b", "standard");
+    seedSummary("b", "newer", 200);
+
+    expect(recentSummaries()).toEqual(["newer", "older"]);
+  });
+
+  test("returns an empty list when there are no summaries", () => {
+    expect(recentSummaries()).toEqual([]);
+  });
+
+  test("pages past a full page of newer background summaries to find users", () => {
+    // 3 (older) user summaries, then more than one page of newer background
+    // summaries. A single fixed window would cut the user rows off; paging must
+    // walk past the first background-only page to return them.
+    seedConversation("u1", "standard");
+    seedSummary("u1", "user u1", 1);
+    seedConversation("u2", "standard");
+    seedSummary("u2", "user u2", 2);
+    seedConversation("u3", "standard");
+    seedSummary("u3", "user u3", 3);
+    for (let i = 0; i < 250; i++) {
+      seedConversation(`bg${i}`, "background");
+      seedSummary(`bg${i}`, `bg ${i}`, 100 + i); // all newer than the users
+    }
+    expect(recentSummaries()).toEqual(["user u3", "user u2", "user u1"]);
+  });
+});

package/src/plugins/defaults/memory/graph/conversation-graph-memory.ts

@@ -15,7 +15,7 @@ import type {
   ImageContent,
   Message,
 } from "@vellumai/plugin-api";
-import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
+import { and, desc, eq, inArray, ne, type SQL, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import {
@@ -24,7 +24,7 @@ import {
 } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { estimateTextTokens } from "../../../../context/token-estimator.js";
-import { getDb } from "../../../../persistence/db-connection.js";
+import { getDb, getMemoryDb } from "../../../../persistence/db-connection.js";
 import { embedWithRetry } from "../../../../persistence/embeddings/embed.js";
 import { generateSparseEmbedding } from "../../../../persistence/embeddings/embedding-backend.js";
 import type { QdrantSparseVector } from "../../../../persistence/embeddings/qdrant-client.js";
@@ -73,6 +73,15 @@ const log = getLogger("graph-conversation-memory");
 
 const ESTIMATED_IMAGE_TOKENS = 1000;
 
+/**
+ * Page size for {@link ConversationGraphMemory.fetchRecentSummaries}. It reads
+ * candidate summary keys a page at a time and stops once three user summaries
+ * are found, so the common case (recent conversations are user ones) touches a
+ * single page regardless of history size. Also bounds the per-page conversation
+ * lookup below SQLite's bound-parameter limit.
+ */
+const RECENT_SUMMARY_PAGE_SIZE = 200;
+
 // ---------------------------------------------------------------------------
 // Per-conversation state
 // ---------------------------------------------------------------------------
@@ -225,59 +234,122 @@ export class ConversationGraphMemory {
   private fetchRecentSummaries(): string[] {
     try {
       const db = getDb();
-      const baseWhere = and(
-        eq(memorySummaries.scope, "conversation"),
-        ne(memorySummaries.scopeKey, this.conversationId),
-      );
+      const memoryDb = getMemoryDb();
+      if (!memoryDb) {
+        return [];
+      }
 
-      // Fetch user conversations first (up to 3)
-      const userRows = db
-        .select({ summary: memorySummaries.summary })
-        .from(memorySummaries)
-        .innerJoin(
-          conversations,
-          eq(memorySummaries.scopeKey, conversations.id),
-        )
-        .where(
-          and(
-            baseWhere,
-            notInArray(conversations.conversationType, [
-              "background",
-              "scheduled",
-            ]),
-          ),
-        )
-        .orderBy(desc(memorySummaries.updatedAt))
-        .limit(3)
-        .all();
+      // Page through candidate summary keys most-recent first from the memory
+      // connection (which holds memory_summaries), resolving each page's
+      // conversation types on the main connection before moving on, and stop as
+      // soon as 3 user summaries are found. Only keys are read here so the full
+      // text is fetched for just the rows returned. conversationType is a
+      // separate lookup rather than a JOIN, since the two tables do not share
+      // a database file; keeping it per-page bounds the scan to the pages
+      // actually needed. A summary whose conversation row is gone is skipped, and
+      // at most 1 background/scheduled summary fills a remaining slot.
+      const selectedKeys: string[] = [];
+      let backgroundKey: string | null = null;
+      // Keyset cursor over (updatedAt, scopeKey), most-recent first. Written as a
+      // row-value comparison so SQLite seeks on the (scope, updated_at) index and
+      // resumes past the last row instead of re-walking every prior page as a
+      // growing OFFSET would. scopeKey is unique per conversation summary, so the
+      // pair is a stable tiebreaker across the (near-never) equal updatedAt.
+      let cursor: { updatedAt: number; scopeKey: string } | null = null;
+      while (selectedKeys.length < 3) {
+        const beyondCursor: SQL | undefined = cursor
+          ? sql`(${memorySummaries.updatedAt}, ${memorySummaries.scopeKey}) < (${cursor.updatedAt}, ${cursor.scopeKey})`
+          : undefined;
+        const page: Array<{ scopeKey: string; updatedAt: number }> = memoryDb
+          .select({
+            scopeKey: memorySummaries.scopeKey,
+            updatedAt: memorySummaries.updatedAt,
+          })
+          .from(memorySummaries)
+          .where(
+            and(
+              eq(memorySummaries.scope, "conversation"),
+              ne(memorySummaries.scopeKey, this.conversationId),
+              beyondCursor,
+            ),
+          )
+          .orderBy(
+            desc(memorySummaries.updatedAt),
+            desc(memorySummaries.scopeKey),
+          )
+          .limit(RECENT_SUMMARY_PAGE_SIZE)
+          .all();
+        if (page.length === 0) {
+          break;
+        }
+        const lastRow = page[page.length - 1]!;
+        cursor = { updatedAt: lastRow.updatedAt, scopeKey: lastRow.scopeKey };
+        const pageKeys = page.map((r) => r.scopeKey);
+
+        const typeByConversation = new Map<string, string>();
+        const rows = db
+          .select({
+            id: conversations.id,
+            type: conversations.conversationType,
+          })
+          .from(conversations)
+          .where(inArray(conversations.id, pageKeys))
+          .all();
+        for (const r of rows) {
+          typeByConversation.set(r.id, r.type);
+        }
 
-      if (userRows.length >= 3) {
-        return userRows.map((r) => r.summary);
+        for (const scopeKey of pageKeys) {
+          const type = typeByConversation.get(scopeKey);
+          if (type === undefined) {
+            continue; // its conversation row is gone, skip it
+          }
+          if (type === "background" || type === "scheduled") {
+            if (backgroundKey === null) {
+              backgroundKey = scopeKey;
+            }
+          } else if (selectedKeys.length < 3) {
+            selectedKeys.push(scopeKey);
+            if (selectedKeys.length >= 3) {
+              break;
+            }
+          }
+        }
+
+        if (page.length < RECENT_SUMMARY_PAGE_SIZE) {
+          break; // last page reached
+        }
+      }
+      if (selectedKeys.length < 3 && backgroundKey !== null) {
+        selectedKeys.push(backgroundKey);
+      }
+      if (selectedKeys.length === 0) {
+        return [];
       }
 
-      // Fill remaining slots with at most 1 background/scheduled conversation
-      const remaining = Math.min(1, 3 - userRows.length);
-      const bgRows = db
-        .select({ summary: memorySummaries.summary })
+      // Fetch the summary text for the selected rows only, then return them in
+      // the selection order (user summaries most-recent first, then the one
+      // background summary).
+      const textByKey = new Map<string, string>();
+      const selectedRows = memoryDb
+        .select({
+          scopeKey: memorySummaries.scopeKey,
+          summary: memorySummaries.summary,
+        })
         .from(memorySummaries)
-        .innerJoin(
-          conversations,
-          eq(memorySummaries.scopeKey, conversations.id),
-        )
         .where(
           and(
-            baseWhere,
-            inArray(conversations.conversationType, [
-              "background",
-              "scheduled",
-            ]),
+            eq(memorySummaries.scope, "conversation"),
+            inArray(memorySummaries.scopeKey, selectedKeys),
           ),
         )
-        .orderBy(desc(memorySummaries.updatedAt))
-        .limit(remaining)
         .all();
-
-      return [...userRows, ...bgRows].map((r) => r.summary);
+      for (const r of selectedRows) {
+        textByKey.set(r.scopeKey, r.summary);
+      }
+      return selectedKeys
+        .map((k) => textByKey.get(k))
+        .filter((s): s is string => s !== undefined);
     } catch (err) {
       log.warn({ err }, "Failed to fetch recent conversation summaries");
       return [];

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

@@ -12,7 +12,9 @@ export function saveGraphMemoryState(
   stateJson: string,
 ): void {
   const mdb = memoryDbOrNull("saveGraphMemoryState");
-  if (!mdb) return;
+  if (!mdb) {
+    return;
+  }
   const now = Date.now();
   mdb
     .insert(conversationGraphMemoryState)
@@ -30,7 +32,9 @@ export function saveGraphMemoryState(
  */
 export function loadGraphMemoryState(conversationId: string): string | null {
   const mdb = memoryDbOrNull("loadGraphMemoryState");
-  if (!mdb) return null;
+  if (!mdb) {
+    return null;
+  }
   const row = mdb
     .select({ stateJson: conversationGraphMemoryState.stateJson })
     .from(conversationGraphMemoryState)
@@ -50,6 +54,8 @@ export function forkGraphMemoryState(
   newConversationId: string,
 ): void {
   const stateJson = loadGraphMemoryState(parentConversationId);
-  if (stateJson == null) return;
+  if (stateJson == null) {
+    return;
+  }
   saveGraphMemoryState(newConversationId, stateJson);
 }

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

@@ -156,7 +156,9 @@ export async function embedGraphTriggerJob(
   const { embedWithBackend } = await import("../embeddings.js");
 
   const db = memoryDbOrNull("embedGraphTriggerJob");
-  if (!db) return;
+  if (!db) {
+    return;
+  }
   const row = db
     .select()
     .from(memoryGraphTriggers)

package/src/plugins/defaults/memory/graph/store.ts

@@ -147,7 +147,9 @@ function rowToTrigger(
  * with `- ` are treated as bullet items and individually deduplicated.
  */
 export function deduplicateParagraphs(content: string): string {
-  if (!content) return content;
+  if (!content) {
+    return content;
+  }
 
   const paragraphs = content.split("\n\n");
   const seen = new Set<string>();
@@ -216,7 +218,9 @@ export function getNode(id: string): MemoryNode | null {
 }
 
 export function getNodesByIds(ids: string[]): MemoryNode[] {
-  if (ids.length === 0) return [];
+  if (ids.length === 0) {
+    return [];
+  }
   const db = memoryDb();
   const rows = db
     .select()
@@ -233,39 +237,66 @@ export function updateNode(
   const db = memoryDb();
   const updates: Record<string, unknown> = {};
 
-  if (changes.content !== undefined)
+  if (changes.content !== undefined) {
     updates.content = deduplicateParagraphs(changes.content);
-  if (changes.type !== undefined) updates.type = changes.type;
-  if (changes.created !== undefined) updates.created = changes.created;
-  if (changes.lastAccessed !== undefined)
+  }
+  if (changes.type !== undefined) {
+    updates.type = changes.type;
+  }
+  if (changes.created !== undefined) {
+    updates.created = changes.created;
+  }
+  if (changes.lastAccessed !== undefined) {
     updates.lastAccessed = changes.lastAccessed;
-  if (changes.lastConsolidated !== undefined)
+  }
+  if (changes.lastConsolidated !== undefined) {
     updates.lastConsolidated = changes.lastConsolidated;
-  if (changes.emotionalCharge !== undefined)
+  }
+  if (changes.emotionalCharge !== undefined) {
     updates.emotionalCharge = JSON.stringify(changes.emotionalCharge);
-  if (changes.fidelity !== undefined) updates.fidelity = changes.fidelity;
-  if (changes.confidence !== undefined) updates.confidence = changes.confidence;
-  if (changes.significance !== undefined)
+  }
+  if (changes.fidelity !== undefined) {
+    updates.fidelity = changes.fidelity;
+  }
+  if (changes.confidence !== undefined) {
+    updates.confidence = changes.confidence;
+  }
+  if (changes.significance !== undefined) {
     updates.significance = changes.significance;
-  if (changes.stability !== undefined) updates.stability = changes.stability;
-  if (changes.reinforcementCount !== undefined)
+  }
+  if (changes.stability !== undefined) {
+    updates.stability = changes.stability;
+  }
+  if (changes.reinforcementCount !== undefined) {
     updates.reinforcementCount = changes.reinforcementCount;
-  if (changes.lastReinforced !== undefined)
+  }
+  if (changes.lastReinforced !== undefined) {
     updates.lastReinforced = changes.lastReinforced;
-  if (changes.sourceConversations !== undefined)
+  }
+  if (changes.sourceConversations !== undefined) {
     updates.sourceConversations = JSON.stringify(changes.sourceConversations);
-  if (changes.sourceType !== undefined) updates.sourceType = changes.sourceType;
-  if (changes.narrativeRole !== undefined)
+  }
+  if (changes.sourceType !== undefined) {
+    updates.sourceType = changes.sourceType;
+  }
+  if (changes.narrativeRole !== undefined) {
     updates.narrativeRole = changes.narrativeRole;
-  if (changes.partOfStory !== undefined)
+  }
+  if (changes.partOfStory !== undefined) {
     updates.partOfStory = changes.partOfStory;
-  if (changes.imageRefs !== undefined)
+  }
+  if (changes.imageRefs !== undefined) {
     updates.imageRefs = changes.imageRefs
       ? JSON.stringify(changes.imageRefs)
       : null;
-  if (changes.eventDate !== undefined) updates.eventDate = changes.eventDate;
+  }
+  if (changes.eventDate !== undefined) {
+    updates.eventDate = changes.eventDate;
+  }
 
-  if (Object.keys(updates).length === 0) return;
+  if (Object.keys(updates).length === 0) {
+    return;
+  }
 
   db.update(memoryGraphNodes)
     .set(updates)
@@ -517,18 +548,30 @@ export function updateTrigger(
 ): void {
   const db = memoryDb();
   const values: Record<string, unknown> = {};
-  if (updates.consumed !== undefined) values.consumed = updates.consumed;
-  if (updates.lastFired !== undefined) values.lastFired = updates.lastFired;
-  if (updates.conditionEmbedding !== undefined)
+  if (updates.consumed !== undefined) {
+    values.consumed = updates.consumed;
+  }
+  if (updates.lastFired !== undefined) {
+    values.lastFired = updates.lastFired;
+  }
+  if (updates.conditionEmbedding !== undefined) {
     values.conditionEmbedding = updates.conditionEmbedding
       ? Buffer.from(updates.conditionEmbedding.buffer)
       : null;
-  if (updates.eventDate !== undefined) values.eventDate = updates.eventDate;
-  if (updates.rampDays !== undefined) values.rampDays = updates.rampDays;
-  if (updates.followUpDays !== undefined)
+  }
+  if (updates.eventDate !== undefined) {
+    values.eventDate = updates.eventDate;
+  }
+  if (updates.rampDays !== undefined) {
+    values.rampDays = updates.rampDays;
+  }
+  if (updates.followUpDays !== undefined) {
     values.followUpDays = updates.followUpDays;
+  }
 
-  if (Object.keys(values).length === 0) return;
+  if (Object.keys(values).length === 0) {
+    return;
+  }
   db.update(memoryGraphTriggers)
     .set(values)
     .where(eq(memoryGraphTriggers.id, id))
@@ -694,25 +737,45 @@ export function applyDiff(
     for (const update of diff.updateNodes) {
       const updates: Record<string, unknown> = {};
       const c = update.changes;
-      if (c.content !== undefined)
+      if (c.content !== undefined) {
         updates.content = deduplicateParagraphs(c.content as string);
-      if (c.type !== undefined) updates.type = c.type;
-      if (c.emotionalCharge !== undefined)
+      }
+      if (c.type !== undefined) {
+        updates.type = c.type;
+      }
+      if (c.emotionalCharge !== undefined) {
         updates.emotionalCharge = JSON.stringify(c.emotionalCharge);
-      if (c.fidelity !== undefined) updates.fidelity = c.fidelity;
-      if (c.confidence !== undefined) updates.confidence = c.confidence;
-      if (c.significance !== undefined) updates.significance = c.significance;
-      if (c.stability !== undefined) updates.stability = c.stability;
-      if (c.reinforcementCount !== undefined)
+      }
+      if (c.fidelity !== undefined) {
+        updates.fidelity = c.fidelity;
+      }
+      if (c.confidence !== undefined) {
+        updates.confidence = c.confidence;
+      }
+      if (c.significance !== undefined) {
+        updates.significance = c.significance;
+      }
+      if (c.stability !== undefined) {
+        updates.stability = c.stability;
+      }
+      if (c.reinforcementCount !== undefined) {
         updates.reinforcementCount = c.reinforcementCount;
-      if (c.narrativeRole !== undefined)
+      }
+      if (c.narrativeRole !== undefined) {
         updates.narrativeRole = c.narrativeRole;
-      if (c.partOfStory !== undefined) updates.partOfStory = c.partOfStory;
-      if (c.imageRefs !== undefined)
+      }
+      if (c.partOfStory !== undefined) {
+        updates.partOfStory = c.partOfStory;
+      }
+      if (c.imageRefs !== undefined) {
         updates.imageRefs = c.imageRefs ? JSON.stringify(c.imageRefs) : null;
-      if (c.sourceConversations !== undefined)
+      }
+      if (c.sourceConversations !== undefined) {
         updates.sourceConversations = JSON.stringify(c.sourceConversations);
-      if (c.eventDate !== undefined) updates.eventDate = c.eventDate;
+      }
+      if (c.eventDate !== undefined) {
+        updates.eventDate = c.eventDate;
+      }
 
       // Record edit history when content changes
       if (updates.content !== undefined) {
@@ -979,14 +1042,19 @@ export function computeGraphStats(): GraphStats {
     if (n.fidelity !== "gone") {
       byFidelity[n.fidelity as keyof FidelityBreakdown] += 1;
     }
-    if (n.significance < 0.15) atRisk++;
+    if (n.significance < 0.15) {
+      atRisk++;
+    }
     sigSum += n.significance;
-    if (oldestCreated === null || n.created < oldestCreated)
+    if (oldestCreated === null || n.created < oldestCreated) {
       oldestCreated = n.created;
-    if (newestCreated === null || n.created > newestCreated)
+    }
+    if (newestCreated === null || n.created > newestCreated) {
       newestCreated = n.created;
-    if (lastReinforced === null || n.lastReinforced > lastReinforced)
+    }
+    if (lastReinforced === null || n.lastReinforced > lastReinforced) {
       lastReinforced = n.lastReinforced;
+    }
   }
 
   // Live edge count: both endpoints must be non-gone.

package/src/plugins/defaults/memory/graph/types.ts

@@ -118,10 +118,13 @@ export interface MemoryNode {
  * and consolidation — organic procedural nodes participate normally.
  */
 export function isCapabilityNode(node: MemoryNode): boolean {
-  if (node.type !== "procedural") return false;
+  if (node.type !== "procedural") {
+    return false;
+  }
   // Old seeding systems: content starts with "skill:{id}\n" or "cli:{name}\n"
-  if (node.content.startsWith("skill:") || node.content.startsWith("cli:"))
+  if (node.content.startsWith("skill:") || node.content.startsWith("cli:")) {
     return true;
+  }
   // New seeding system (capability-seed.ts): content matches
   // 'The "{name}" skill ({id}) is available.' or
   // 'The "assistant {name}" CLI command is available.'
@@ -156,15 +159,25 @@ export type CapabilityKind = "skill" | "cli";
  * `extractCapabilityId` recognize.
  */
 export function capabilityKind(node: MemoryNode): CapabilityKind | null {
-  if (node.type !== "procedural") return null;
+  if (node.type !== "procedural") {
+    return null;
+  }
 
   const source = node.sourceConversations[0];
-  if (source?.startsWith(CAPABILITY_SKILL_SOURCE_PREFIX)) return "skill";
-  if (source?.startsWith(CAPABILITY_CLI_SOURCE_PREFIX)) return "cli";
+  if (source?.startsWith(CAPABILITY_SKILL_SOURCE_PREFIX)) {
+    return "skill";
+  }
+  if (source?.startsWith(CAPABILITY_CLI_SOURCE_PREFIX)) {
+    return "cli";
+  }
 
   // Fallback: classify by seeded content shape when the source key is absent.
-  if (node.content.startsWith("cli:")) return "cli";
-  if (node.content.startsWith("skill:")) return "skill";
+  if (node.content.startsWith("cli:")) {
+    return "cli";
+  }
+  if (node.content.startsWith("skill:")) {
+    return "skill";
+  }
   if (
     node.content.startsWith('The "assistant ') &&
     node.content.includes(" CLI command")

package/src/plugins/defaults/memory/graph-topology/__tests__/build-memory-graph.test.ts

@@ -15,6 +15,7 @@ function entry(
     edges: [],
     leaves: [],
     modifiedAt: 1,
+    freshAt: 1,
     ...over,
   };
 }