@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/__tests__/memory-retrospective-startup-cleanup.test.ts

@@ -0,0 +1,213 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock state — reset between tests.
+// ---------------------------------------------------------------------------
+
+type ConvRow = {
+  id: string;
+  source: string | null;
+  last_message_at: number | null;
+};
+type JobRow = {
+  type: string;
+  status: string;
+  payload: string;
+};
+
+let mockConversations: ConvRow[] = [];
+let mockJobs: JobRow[] = [];
+let deletedIds: string[] = [];
+
+mock.module("../db-connection.js", () => ({
+  getDb: () => ({
+    select: (cols?: Record<string, unknown>) => ({
+      from: (_table: { _: { name: string } } | unknown) => ({
+        where: (..._args: unknown[]) => ({
+          all: () => {
+            // Heuristic: tests only construct two query shapes — the jobs
+            // query and the conversations query. Distinguish by the first
+            // requested column shape.
+            const colKeys = cols ? Object.keys(cols) : [];
+            if (colKeys.includes("conversationId")) {
+              return mockJobs
+                .filter(
+                  (j) =>
+                    j.type === "memory_retrospective" &&
+                    (j.status === "pending" || j.status === "running"),
+                )
+                .map((j) => {
+                  let convId: string | null = null;
+                  try {
+                    const parsed = JSON.parse(j.payload) as {
+                      conversationId?: unknown;
+                    };
+                    if (typeof parsed.conversationId === "string") {
+                      convId = parsed.conversationId;
+                    }
+                  } catch {
+                    // Ignore malformed payload
+                  }
+                  return { conversationId: convId };
+                });
+            }
+            // Otherwise, this is the conversation query.
+            // The test harness applies its OWN filter logic below since the
+            // production code uses drizzle's combinator. We expose all rows
+            // tagged with the right source/last_message_at, and the test
+            // post-filters them to mirror the production query.
+            return mockConversations
+              .filter((c) => c.source === "memory-retrospective")
+              .filter(
+                (c) =>
+                  c.last_message_at !== null &&
+                  c.last_message_at < injectedNowMinusOrphanAgeMs,
+              )
+              .filter((c) => !activeJobConvIds.has(c.id))
+              .map((c) => ({ id: c.id }));
+          },
+        }),
+      }),
+    }),
+  }),
+}));
+
+let activeJobConvIds = new Set<string>();
+let injectedNowMinusOrphanAgeMs = 0;
+
+mock.module("../conversation-crud.js", () => ({
+  deleteConversation: (id: string) => {
+    deletedIds.push(id);
+    mockConversations = mockConversations.filter((c) => c.id !== id);
+  },
+}));
+
+import { sweepOrphanMemoryRetrospectiveConversations } from "../memory-retrospective-startup-cleanup.js";
+
+const ORPHAN_AGE_MS = 60 * 60 * 1000;
+
+function rebuildActiveJobSet(): void {
+  activeJobConvIds = new Set();
+  for (const j of mockJobs) {
+    if (
+      j.type !== "memory_retrospective" ||
+      (j.status !== "pending" && j.status !== "running")
+    ) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(j.payload) as { conversationId?: unknown };
+      if (typeof parsed.conversationId === "string") {
+        activeJobConvIds.add(parsed.conversationId);
+      }
+    } catch {
+      // ignore
+    }
+  }
+}
+
+describe("sweepOrphanMemoryRetrospectiveConversations", () => {
+  beforeEach(() => {
+    mockConversations = [];
+    mockJobs = [];
+    deletedIds = [];
+    activeJobConvIds = new Set();
+    injectedNowMinusOrphanAgeMs = 0;
+  });
+
+  afterEach(() => {
+    mockConversations = [];
+    mockJobs = [];
+  });
+
+  test("sweeps an old memory-retrospective conversation with no active job", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "old-orphan",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(1);
+    expect(deletedIds).toEqual(["old-orphan"]);
+  });
+
+  test("does NOT sweep recent memory-retrospective conversations", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "fresh-bg",
+        source: "memory-retrospective",
+        last_message_at: now - 60_000,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+
+  test("does NOT sweep conversations of OTHER sources, even when old", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "auto-analysis-old",
+        source: "auto-analysis",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+  });
+
+  test("does NOT sweep an orphan whose source conversation has an active job", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "orphan-but-protected",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    mockJobs = [
+      {
+        type: "memory_retrospective",
+        status: "pending",
+        payload: JSON.stringify({ conversationId: "orphan-but-protected" }),
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+
+  test("running across an empty workspace returns swept=0 without errors", () => {
+    const result = sweepOrphanMemoryRetrospectiveConversations();
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+});

package/src/memory/__tests__/memory-retrospective-trigger-check.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+
+import { shouldEnqueueRetrospective } from "../memory-retrospective-trigger-check.js";
+
+const THRESHOLDS = {
+  timeThresholdMs: 30 * 60 * 1000, // 30 min
+  messageThreshold: 10,
+  minCooldownMs: 5 * 60 * 1000, // 5 min
+};
+
+describe("shouldEnqueueRetrospective", () => {
+  test("no state — returns 'interval' regardless of message count", () => {
+    const result = shouldEnqueueRetrospective({
+      state: null,
+      newMessageCount: 0,
+      now: Date.now(),
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+
+  test("cooldown gate — within minCooldownMs, returns null even if other thresholds would trip", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 60_000 }, // 1 min ago
+      newMessageCount: 50, // way over threshold
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBeNull();
+  });
+
+  test("cooldown elapsed + time threshold reached — returns 'interval'", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 31 * 60_000 },
+      newMessageCount: 1,
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+
+  test("cooldown elapsed + time threshold not reached + message threshold met — returns 'message_count'", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 6 * 60_000 }, // past cooldown
+      newMessageCount: 10, // exactly at threshold
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("message_count");
+  });
+
+  test("cooldown elapsed + neither threshold met — returns null", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 6 * 60_000 },
+      newMessageCount: 5, // below threshold
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBeNull();
+  });
+
+  test("time threshold at exact boundary — returns 'interval'", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 30 * 60_000 },
+      newMessageCount: 1,
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+
+  test("message threshold prefers 'message_count' label when both could fire (interval also at boundary)", () => {
+    // When the interval is also at threshold AND there are also enough
+    // new messages, interval wins because it's evaluated first — the
+    // trigger label is for observability only, the action is the same.
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 31 * 60_000 },
+      newMessageCount: 20,
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+});

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -23,6 +23,7 @@ import { initializeDb } from "../db-init.js";
 import {
   backfillMemoryV2ActivationMessageId,
   getMemoryV2ActivationLogByMessageIds,
+  type MemoryV2ConceptRowRecord,
   recordMemoryV2ActivationLog,
 } from "../memory-v2-activation-log-store.js";
 import { memoryV2ActivationLogs } from "../schema.js";
@@ -66,6 +67,74 @@ describe("memory-v2-activation-log-store", () => {
     expect(result!.config).toEqual(sampleConfig);
   });
 
+  test("round-trip: router-mode log row with zeroed activations and source: 'router'", () => {
+    const conversationId = "conv-router";
+    const messageId = "msg-router";
+
+    const routerConcepts: MemoryV2ConceptRowRecord[] = [
+      {
+        slug: "concept-router-a",
+        finalActivation: 0,
+        ownActivation: 0,
+        priorActivation: 0,
+        simUser: 0,
+        simAssistant: 0,
+        simNow: 0,
+        simUserRerankBoost: 0,
+        simAssistantRerankBoost: 0,
+        inRerankPool: false,
+        spreadContribution: 0,
+        source: "router",
+        status: "injected",
+      },
+      {
+        slug: "concept-router-b",
+        finalActivation: 0,
+        ownActivation: 0,
+        priorActivation: 0,
+        simUser: 0,
+        simAssistant: 0,
+        simNow: 0,
+        simUserRerankBoost: 0,
+        simAssistantRerankBoost: 0,
+        inRerankPool: false,
+        spreadContribution: 0,
+        source: "router",
+        status: "not_injected",
+      },
+    ];
+
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 7,
+      mode: "router",
+      concepts: routerConcepts,
+      config: sampleConfig,
+    });
+
+    backfillMemoryV2ActivationMessageId(conversationId, messageId);
+
+    const result = getMemoryV2ActivationLogByMessageIds([messageId]);
+    expect(result).not.toBeNull();
+    expect(result!.conversationId).toBe(conversationId);
+    expect(result!.turn).toBe(7);
+    expect(result!.mode).toBe("router");
+    expect(result!.concepts).toEqual(routerConcepts);
+    expect(result!.config).toEqual(sampleConfig);
+    for (const concept of result!.concepts) {
+      expect(concept.source).toBe("router");
+      expect(concept.finalActivation).toBe(0);
+      expect(concept.ownActivation).toBe(0);
+      expect(concept.priorActivation).toBe(0);
+      expect(concept.simUser).toBe(0);
+      expect(concept.simAssistant).toBe(0);
+      expect(concept.simNow).toBe(0);
+      expect(concept.simUserRerankBoost).toBe(0);
+      expect(concept.simAssistantRerankBoost).toBe(0);
+      expect(concept.spreadContribution).toBe(0);
+    }
+  });
+
   test("returns null for empty messageIds array", () => {
     const result = getMemoryV2ActivationLogByMessageIds([]);
     expect(result).toBeNull();

package/src/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -117,6 +117,7 @@ describe("memory-v2-concept-frequency", () => {
       in_context: 1,
       not_injected: 0,
       page_missing: 0,
+      corrupt: 0,
     });
     expect(bySlug.get("alice")!.totalEvaluations).toBe(3);
     expect(bySlug.get("alice")!.onDisk).toBe(true);
@@ -127,6 +128,7 @@ describe("memory-v2-concept-frequency", () => {
       in_context: 0,
       not_injected: 1,
       page_missing: 0,
+      corrupt: 0,
     });
     expect(bySlug.get("bob")!.totalEvaluations).toBe(2);
     expect(bySlug.get("bob")!.onDisk).toBe(true);
@@ -136,6 +138,7 @@ describe("memory-v2-concept-frequency", () => {
       in_context: 0,
       not_injected: 0,
       page_missing: 1,
+      corrupt: 0,
     });
     expect(bySlug.get("charlie")!.onDisk).toBe(false);
     expect(bySlug.get("charlie")!.lastInjectedAt).toBeNull();

package/src/memory/bookmark-crud.ts

@@ -0,0 +1,179 @@
+import { desc, eq } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import type { DrizzleDb } from "./db-connection.js";
+import { stringifyMessageContent } from "./message-content.js";
+import { conversations, messageBookmarks, messages } from "./schema.js";
+
+/**
+ * Wire-shape representation of a bookmark, joined with the bookmarked
+ * message and its parent conversation. Mirrors
+ * `clients/shared/Network/BookmarkSummary.swift` — dates are emitted as
+ * unix-millisecond integers, and the message preview is capped to keep
+ * the list payload bounded.
+ */
+export interface BookmarkSummary {
+  id: string;
+  messageId: string;
+  conversationId: string;
+  conversationTitle: string | null;
+  messagePreview: string;
+  /** "user" | "assistant" — kept as a free-form string so it round-trips raw. */
+  messageRole: string;
+  /** Unix milliseconds. */
+  messageCreatedAt: number;
+  /** Unix milliseconds. */
+  createdAt: number;
+}
+
+const PREVIEW_MAX_CHARS = 240;
+
+/**
+ * Decode the on-disk message content (legacy plain string OR JSON-serialized
+ * `ContentBlock[]`) into a single text string and cap it at
+ * `PREVIEW_MAX_CHARS`. Without the decode step, modern rows would render as
+ * raw JSON in the bookmark list.
+ */
+function buildPreview(content: string): string {
+  const text = stringifyMessageContent(content);
+  return text.length > PREVIEW_MAX_CHARS
+    ? text.slice(0, PREVIEW_MAX_CHARS)
+    : text;
+}
+
+/**
+ * Shared SELECT shape used by the JOIN-based readers. Pulling this out
+ * avoids duplicating the column list and the row-mapping below.
+ */
+const BOOKMARK_JOIN_COLUMNS = {
+  id: messageBookmarks.id,
+  messageId: messageBookmarks.messageId,
+  conversationId: messageBookmarks.conversationId,
+  createdAt: messageBookmarks.createdAt,
+  conversationTitle: conversations.title,
+  messageContent: messages.content,
+  messageRole: messages.role,
+  messageCreatedAt: messages.createdAt,
+} as const;
+
+type BookmarkJoinRow = {
+  id: string;
+  messageId: string;
+  conversationId: string;
+  createdAt: number;
+  conversationTitle: string | null;
+  messageContent: string;
+  messageRole: string;
+  messageCreatedAt: number;
+};
+
+function rowToSummary(row: BookmarkJoinRow): BookmarkSummary {
+  return {
+    id: row.id,
+    messageId: row.messageId,
+    conversationId: row.conversationId,
+    conversationTitle: row.conversationTitle,
+    messagePreview: buildPreview(row.messageContent),
+    messageRole: row.messageRole,
+    messageCreatedAt: row.messageCreatedAt,
+    createdAt: row.createdAt,
+  };
+}
+
+function selectBookmarkJoin(db: DrizzleDb) {
+  return db
+    .select(BOOKMARK_JOIN_COLUMNS)
+    .from(messageBookmarks)
+    .innerJoin(messages, eq(messages.id, messageBookmarks.messageId))
+    .innerJoin(
+      conversations,
+      eq(conversations.id, messageBookmarks.conversationId),
+    );
+}
+
+/**
+ * List all bookmarks newest-first, joined against `messages` and
+ * `conversations`. Bookmarks whose parent message or conversation has
+ * been deleted are naturally excluded by the inner-join semantics; the
+ * `ON DELETE CASCADE` on the FKs means rows should never end up in this
+ * orphan state, but the join provides a defense-in-depth guarantee.
+ */
+export function listBookmarks(db: DrizzleDb): BookmarkSummary[] {
+  const rows = selectBookmarkJoin(db)
+    .orderBy(desc(messageBookmarks.createdAt))
+    .all();
+  return rows.map(rowToSummary);
+}
+
+/**
+ * Create a bookmark for the given message and return its JOIN-shaped
+ * {@link BookmarkSummary}. Idempotent on the unique `message_id` index —
+ * if a bookmark already exists for `messageId`, the existing summary is
+ * returned and no new row is inserted.
+ */
+export function createBookmark(
+  db: DrizzleDb,
+  params: { messageId: string; conversationId: string },
+): BookmarkSummary {
+  const { messageId, conversationId } = params;
+  const existing = db
+    .select({ id: messageBookmarks.id })
+    .from(messageBookmarks)
+    .where(eq(messageBookmarks.messageId, messageId))
+    .get();
+  if (existing) return readBookmarkSummaryOrThrow(db, existing.id);
+
+  const id = uuid();
+  try {
+    db.insert(messageBookmarks)
+      .values({ id, messageId, conversationId, createdAt: Date.now() })
+      .run();
+  } catch (err) {
+    // Lost a race against a concurrent create — fall back to fetch by
+    // messageId so we still return the winning row.
+    const winner = db
+      .select({ id: messageBookmarks.id })
+      .from(messageBookmarks)
+      .where(eq(messageBookmarks.messageId, messageId))
+      .get();
+    if (!winner) throw err;
+    return readBookmarkSummaryOrThrow(db, winner.id);
+  }
+  return readBookmarkSummaryOrThrow(db, id);
+}
+
+function readBookmarkSummaryOrThrow(
+  db: DrizzleDb,
+  id: string,
+): BookmarkSummary {
+  const row = selectBookmarkJoin(db).where(eq(messageBookmarks.id, id)).get();
+  if (!row) {
+    // Unreachable: caller just observed (or inserted) this id.
+    throw new Error(`Bookmark ${id} disappeared between insert and read`);
+  }
+  return rowToSummary(row);
+}
+
+/**
+ * Delete the bookmark (if any) attached to the given `messageId`.
+ * Returns true iff a row was removed.
+ *
+ * Drizzle's high-level `.run()` is typed as `void` for the sync sqlite
+ * driver, so we check existence with a follow-up SELECT instead of
+ * relying on a row-count from the delete statement.
+ */
+export function deleteBookmarkByMessageId(
+  db: DrizzleDb,
+  messageId: string,
+): boolean {
+  const existed = db
+    .select({ id: messageBookmarks.id })
+    .from(messageBookmarks)
+    .where(eq(messageBookmarks.messageId, messageId))
+    .get();
+  if (!existed) return false;
+  db.delete(messageBookmarks)
+    .where(eq(messageBookmarks.messageId, messageId))
+    .run();
+  return true;
+}

package/src/memory/context-search/__tests__/agent-runner-redaction.test.ts

@@ -4,7 +4,7 @@
  *
  * `redactWorkspaceEvidence` scrubs secrets from workspace-sourced evidence
  * excerpts before they are serialised into the prompt that is sent to the
- * external recall LLM provider. Memory/PKB/conversation evidence is left
+ * external recall LLM provider. Memory/conversation evidence is left
  * untouched — those sources contain intentionally stored user content.
  */
 
@@ -65,7 +65,10 @@ describe("redactWorkspaceEvidence", () => {
 
   test("does NOT modify non-secret workspace excerpts", () => {
     const safeContent = "This is a normal comment explaining the architecture.";
-    const original = makeEvidence({ source: "workspace", excerpt: safeContent });
+    const original = makeEvidence({
+      source: "workspace",
+      excerpt: safeContent,
+    });
     const [result] = redactWorkspaceEvidence([original]);
 
     expect(result.excerpt).toBe(safeContent);
@@ -74,11 +77,11 @@ describe("redactWorkspaceEvidence", () => {
   });
 
   test("does NOT redact non-workspace sources", () => {
-    // Memory/PKB/conversation evidence is intentionally stored user content —
+    // Memory/conversation evidence is intentionally stored user content —
     // redacting it would break recall for things the user deliberately noted.
     const secretLike = "token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.abc";
 
-    for (const source of ["memory", "pkb", "conversations"] as const) {
+    for (const source of ["memory", "conversations"] as const) {
       const original = makeEvidence({ source, excerpt: secretLike });
       const [result] = redactWorkspaceEvidence([original]);
 
@@ -89,8 +92,16 @@ describe("redactWorkspaceEvidence", () => {
 
   test("redacts multiple secrets across multiple workspace evidence items", () => {
     const results = redactWorkspaceEvidence([
-      makeEvidence({ id: "ev-1", source: "workspace", excerpt: `key=${ANTHROPIC_KEY}` }),
-      makeEvidence({ id: "ev-2", source: "workspace", excerpt: GENERIC_SECRET_EXCERPT }),
+      makeEvidence({
+        id: "ev-1",
+        source: "workspace",
+        excerpt: `key=${ANTHROPIC_KEY}`,
+      }),
+      makeEvidence({
+        id: "ev-2",
+        source: "workspace",
+        excerpt: GENERIC_SECRET_EXCERPT,
+      }),
     ]);
 
     expect(results[0].excerpt).not.toContain(ANTHROPIC_KEY);
@@ -101,7 +112,10 @@ describe("redactWorkspaceEvidence", () => {
 
   test("does not mutate the original evidence objects", () => {
     const secret = ANTHROPIC_KEY;
-    const original = makeEvidence({ source: "workspace", excerpt: `key=${secret}` });
+    const original = makeEvidence({
+      source: "workspace",
+      excerpt: `key=${secret}`,
+    });
     const originalExcerpt = original.excerpt;
 
     redactWorkspaceEvidence([original]);
@@ -111,8 +125,16 @@ describe("redactWorkspaceEvidence", () => {
 
   test("handles mixed sources in one batch correctly", () => {
     const secret = ANTHROPIC_KEY;
-    const wsItem = makeEvidence({ id: "ev-ws", source: "workspace", excerpt: `key=${secret}` });
-    const memItem = makeEvidence({ id: "ev-mem", source: "memory", excerpt: `key=${secret}` });
+    const wsItem = makeEvidence({
+      id: "ev-ws",
+      source: "workspace",
+      excerpt: `key=${secret}`,
+    });
+    const memItem = makeEvidence({
+      id: "ev-mem",
+      source: "memory",
+      excerpt: `key=${secret}`,
+    });
 
     const [wsResult, memResult] = redactWorkspaceEvidence([wsItem, memItem]);
 

package/src/memory/context-search/agent-protocol.ts

@@ -34,6 +34,7 @@ type RecallFinishFallbackReason =
   | "malformed_finish_payload"
   | "invalid_confidence"
   | "invalid_citation_ids"
+  | "missing_citations"
   | "unknown_citation_ids"
   | "empty_answer";
 
@@ -57,7 +58,6 @@ const DEFAULT_MAX_SEARCH_CALLS = 4;
 
 const RECALL_SOURCE_DESCRIPTIONS: Record<RecallSource, string> = {
   memory: "durable memory graph facts and relationship/context memories",
-  pkb: "personal knowledge base notes, NOW context, and pinned context",
   conversations: "past assistant conversations and conversation summaries",
   workspace: "files and text available in the current workspace",
 };
@@ -293,6 +293,10 @@ export function validateFinishRecallPayload(
     return fallbackFinish("invalid_citation_ids");
   }
 
+  if (payload.citation_ids.length === 0) {
+    return fallbackFinish("missing_citations");
+  }
+
   const citationValidation = validateRecallCitationIds(
     payload.citation_ids,
     evidence,