@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/daemon/memory-v2-startup.ts

@@ -3,7 +3,8 @@
 // ---------------------------------------------------------------------------
 //
 // Small focused module that holds the gating + dispatch logic for v2-specific
-// startup work invoked from `lifecycle.ts`. Lives in its own file so the unit
+// startup work invoked from `lifecycle.ts` (and, for the post-credential
+// capability reseed, from the secrets route). Lives in its own file so the unit
 // test for the gate does not have to mount the entire lifecycle import graph.
 
 import type { AssistantConfig } from "../config/schema.js";
@@ -48,6 +49,104 @@ export function maybeSeedMemoryV2CliCommands(config: AssistantConfig): void {
     .catch((err) => log.warn({ err }, "Failed to seed v2 CLI-command entries"));
 }
 
+/**
+ * Re-seed the v2 skill and CLI-command capability entries once a managed-proxy
+ * credential lands, closing the first-boot race where the daemon's startup seed
+ * runs before the platform has provisioned the managed embedding credential.
+ *
+ * On a brand-new managed assistant the memory worker fires the startup seed
+ * (`maybeSeedMemoryV2Skills` / `maybeSeedMemoryV2CliCommands`) seconds after
+ * boot, but the platform pushes `vellum:assistant_api_key` (the credential the
+ * managed Gemini embedding backend needs) tens of seconds later. The seed's
+ * `embedWithBackend` call throws `EmbeddingBackendUnavailableError` before the
+ * skill/CLI `entries` cache is replaced, so `listSkillEntries()` /
+ * `listCliCommandEntries()` stay empty and the synthetic `skills/<id>` and
+ * `cli-commands/<name>` rows never reach the page index — leaving the v3 needle
+ * finder lane and always-candidate skill pinning with nothing to surface until
+ * the next daemon restart. Re-running the seed when the credential arrives
+ * restores the capability pages without a restart.
+ *
+ * Gated on the managed-proxy prerequisites now being satisfied (both the
+ * platform base URL and the assistant API key present) so a non-managed
+ * credential write — or a partial update that has not yet completed the pair —
+ * does not kick a doomed embed. Idempotent: `seedV2SkillEntries` /
+ * `seedV2CliCommandEntries` atomically replace their caches, so a redundant
+ * reseed (the startup seed already succeeded) is cheap and harmless. The two
+ * catalogs are independent, so they reseed in parallel. Callers invoke this
+ * detached (`void`) — it must not block the credential-store response.
+ *
+ * Reseeding alone only repopulates the shared page index — v3 reads its
+ * synthetic capability rows from the v2 stores, but its memoized lanes and its
+ * `memory_v3_sections` dense store refresh only on the v3 maintain pass (6-hour
+ * backstop). So when v3 is live, enqueue a `memory_v3_maintain` job after the
+ * reseed: its capability-reconcile stage embeds the freshly-seeded rows into the
+ * dense store and its lane-invalidation stage forces a rebuild against the now-
+ * populated index, so v3 surfaces the skill/CLI pages within seconds instead of
+ * waiting out the backstop.
+ */
+export async function maybeReseedCapabilitiesAfterManagedCredential(
+  config: AssistantConfig,
+): Promise<void> {
+  if (!config.memory.v2.enabled) return;
+
+  const { hasManagedProxyPrereqs } =
+    await import("../providers/platform-proxy/context.js");
+  if (!(await hasManagedProxyPrereqs())) return;
+
+  // Skills and CLI commands are independent catalogs sharing the unified
+  // collection — reseed in parallel, each contained so one catalog's embed
+  // failure does not abort the other or reject the detached caller.
+  const catalogs: ReadonlyArray<[label: string, seed: () => Promise<void>]> = [
+    [
+      "skill",
+      async () => {
+        const { seedV2SkillEntries } =
+          await import("../memory/v2/skill-store.js");
+        await seedV2SkillEntries({ throwOnError: true });
+      },
+    ],
+    [
+      "CLI-command",
+      async () => {
+        const { seedV2CliCommandEntries } =
+          await import("../memory/v2/cli-command-store.js");
+        await seedV2CliCommandEntries({ throwOnError: true });
+      },
+    ],
+  ];
+
+  await Promise.all(
+    catalogs.map(async ([label, seed]) => {
+      try {
+        await seed();
+        log.info(
+          `Memory v2 ${label} entries seeded after managed proxy credential update`,
+        );
+      } catch (err) {
+        log.warn(
+          { err },
+          `Failed to seed v2 ${label} entries after managed proxy credential update`,
+        );
+      }
+    }),
+  );
+
+  // The stores (and the page index) are now populated; when v3 is live, kick a
+  // maintain pass so it embeds the capability rows into `memory_v3_sections` and
+  // invalidates its lanes immediately rather than waiting out the 6h backstop.
+  const { isMemoryV3Live } = await import("../config/memory-v3-gate.js");
+  if (!isMemoryV3Live(config)) return;
+  try {
+    const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
+    enqueueMemoryJob("memory_v3_maintain", {});
+  } catch (err) {
+    log.warn(
+      { err },
+      "Failed to enqueue memory_v3_maintain after managed proxy credential update",
+    );
+  }
+}
+
 /**
  * Build the v2 BM25 corpus stats (per-token document frequencies + avg doc
  * length), then re-seed the v2 skill entries so any skills written during

package/src/daemon/message-provenance.ts

@@ -26,6 +26,7 @@ export function parseProvenanceTrustClass(
     if (
       trustClass === "guardian" ||
       trustClass === "trusted_contact" ||
+      trustClass === "unverified_contact" ||
       trustClass === "unknown"
     ) {
       return trustClass;
@@ -43,6 +44,7 @@ export function filterMessagesForUntrustedActor(
     const provenanceTrustClass = parseProvenanceTrustClass(m.metadata);
     return (
       provenanceTrustClass === "trusted_contact" ||
+      provenanceTrustClass === "unverified_contact" ||
       provenanceTrustClass === "unknown"
     );
   });

package/src/daemon/message-types/contacts.ts

@@ -54,7 +54,6 @@ export interface ContactChannelPayload {
   type: string;
   address: string;
   isPrimary: boolean;
-  externalUserId?: string;
   status: string;
   policy: string;
   verifiedAt?: number;

package/src/daemon/message-types/conversations.ts

@@ -462,9 +462,9 @@ export interface ContextCompacted {
    * - `summaryCharCount`: length of the produced summary text.
    * - `summaryHeaderCount`: number of `## ` section headers in the summary.
    * - `summaryHadMemoryEcho`: `true` if the summary contains any runtime
-   *   injection tag (e.g. `<memory`, `<turn_context>`, `<workspace>`).
-   *   Should always be `false` — `true` indicates the compaction strip
-   *   logic failed to remove an injected block from the summarizer input.
+   *   injection tag (e.g. `<memory`, `<turn_context>`, `<workspace>`). The
+   *   durable summary should be clean prose, so `true` flags an echoed or
+   *   invented tag worth investigating.
    */
   summaryCharCount?: number;
   summaryHeaderCount?: number;

package/src/daemon/message-types/sync.ts

@@ -10,7 +10,6 @@ export { type SyncChangedEvent, SyncChangedEventSchema };
 export const SYNC_TAGS = {
   assistantAvatar: "assistant:self:avatar",
   assistantIdentity: "assistant:self:identity",
-  assistantIdentityIntro: "assistant:self:identity-intro",
   assistantConfig: "assistant:self:config",
   assistantSounds: "assistant:self:sounds",
   assistantSchedules: "assistant:self:schedules",

package/src/daemon/message-types/web-activity.ts

@@ -9,7 +9,11 @@ export type WebSearchProviderId =
   | "anthropic-native"
   | "brave"
   | "perplexity"
-  | "tavily";
+  | "tavily"
+  | "firecrawl";
+
+/** Provider that backed a `web_fetch` call. `default` is the built-in fetcher. */
+export type WebFetchProviderId = "default" | "firecrawl";
 
 export interface WebSearchResultItem {
   rank: number; // 1-indexed
@@ -35,6 +39,8 @@ export interface WebSearchMetadata {
 export interface WebFetchMetadata {
   url: string;
   finalUrl: string;
+  /** Provider that served the fetch. Defaults to the built-in fetcher. */
+  provider?: WebFetchProviderId;
   status: number;
   contentType?: string;
   byteCount: number;

package/src/daemon/message-types/workflows.ts

@@ -18,6 +18,13 @@ import type { WorkflowRunStatus } from "../../workflows/journal-store.js";
 export interface WorkflowProgress {
   type: "workflow_progress";
   runId: string;
+  /**
+   * Originating conversation id, when launched from one; lets `broadcastMessage`
+   * auto-scope + seq-stamp the event to that conversation's SSE stream. Omitted
+   * for a conversationless run (e.g. a scheduled workflow), which broadcasts
+   * unscoped for raw SSE listeners and the DB record.
+   */
+  conversationId?: string;
   /** Latest phase title, when this emission came from a `phase(...)` call. */
   phase?: string;
   /** Run label (the workflow's `meta.name`), for client display. */
@@ -36,6 +43,13 @@ export interface WorkflowProgress {
 export interface WorkflowCompleted {
   type: "workflow_completed";
   runId: string;
+  /**
+   * Originating conversation id, when launched from one; lets `broadcastMessage`
+   * auto-scope + seq-stamp the event to that conversation's SSE stream. Omitted
+   * for a conversationless run (e.g. a scheduled workflow), which broadcasts
+   * unscoped for raw SSE listeners and the DB record.
+   */
+  conversationId?: string;
   status: WorkflowRunStatus;
   agentsSpawned: number;
   inputTokens: number;
@@ -44,6 +58,74 @@ export interface WorkflowCompleted {
   summary?: string;
 }
 
+/**
+ * A workflow run has started. Emitted once at launch, before any leaf events.
+ */
+export interface WorkflowStarted {
+  type: "workflow_started";
+  runId: string;
+  /**
+   * Originating conversation id; lets `broadcastMessage` auto-scope +
+   * seq-stamp the event to the conversation's SSE stream.
+   */
+  conversationId: string;
+  /**
+   * Tool-use id of the `skill_execute` block that launched this run, for
+   * anchoring the inline workflow card to the exact spawn tool call.
+   */
+  toolUseId?: string;
+  /** Run label (the workflow's `meta.name`), for client display. */
+  label?: string;
+}
+
+/**
+ * A leaf agent within a workflow run has started. `seq` orders leaves within
+ * the run for stable client-side tree placement.
+ */
+export interface WorkflowLeafStarted {
+  type: "workflow_leaf_started";
+  runId: string;
+  /**
+   * Originating conversation id; lets `broadcastMessage` auto-scope +
+   * seq-stamp the event to the conversation's SSE stream.
+   */
+  conversationId: string;
+  seq: number;
+  /** Leaf label, for client display. */
+  label?: string;
+  /** Phase the leaf belongs to, when the workflow declares phases. */
+  phase?: string;
+  /** Short summary of the leaf's prompt, for client display. */
+  promptSummary?: string;
+}
+
+/**
+ * A leaf agent within a workflow run has finished. `seq` matches the
+ * corresponding `workflow_leaf_started` event.
+ */
+export interface WorkflowLeafFinished {
+  type: "workflow_leaf_finished";
+  runId: string;
+  /**
+   * Originating conversation id; lets `broadcastMessage` auto-scope +
+   * seq-stamp the event to the conversation's SSE stream.
+   */
+  conversationId: string;
+  seq: number;
+  status: "completed" | "failed";
+  /** Leaf label, for client display. */
+  label?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  /** Short summary of the leaf's result, for client display. */
+  resultSummary?: string;
+}
+
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
-export type _WorkflowsServerMessages = WorkflowProgress | WorkflowCompleted;
+export type _WorkflowsServerMessages =
+  | WorkflowProgress
+  | WorkflowCompleted
+  | WorkflowStarted
+  | WorkflowLeafStarted
+  | WorkflowLeafFinished;

package/src/daemon/orphan-reaper.test.ts

@@ -21,7 +21,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const { parseProcStat, selectReapable } = await import("./orphan-reaper.js");
-const { DaemonConfigSchema } = await import("../config/schemas/platform.js");
 
 describe("parseProcStat", () => {
   test("parses a normal stat line", () => {
@@ -89,24 +88,6 @@ describe("selectReapable", () => {
   });
 });
 
-describe("daemon.reapOrphanedSubprocesses gate", () => {
-  test("defaults to off so the reaper is opt-in", () => {
-    // GIVEN a daemon config with the reaper flag unspecified
-    // WHEN it is parsed with schema defaults
-    const parsed = DaemonConfigSchema.parse({});
-    // THEN the reaper is disabled unless explicitly turned on
-    expect(parsed.reapOrphanedSubprocesses).toBe(false);
-  });
-
-  test("honors an explicit opt-in", () => {
-    // GIVEN a daemon config that explicitly enables the reaper
-    // WHEN it is parsed
-    const parsed = DaemonConfigSchema.parse({ reapOrphanedSubprocesses: true });
-    // THEN the flag is respected
-    expect(parsed.reapOrphanedSubprocesses).toBe(true);
-  });
-});
-
 // ── Integration: real reparented orphan on Linux ────────────────────────────
 const itLinux = process.platform === "linux" ? test : test.skip;
 

package/src/daemon/orphan-reaper.ts

@@ -26,9 +26,7 @@
  * macOS dev, or if an init such as tini is ever placed above the daemon),
  * orphans reparent to that init and are reaped there, so there is nothing for
  * this to do. Because the daemon is PID 1, orphans already reparent to it and
- * `PR_SET_CHILD_SUBREAPER` is unnecessary. It is additionally gated behind the
- * `daemon.reapOrphanedSubprocesses` config flag (default off) so the behavior
- * can be enabled per workspace for validation before becoming the default.
+ * `PR_SET_CHILD_SUBREAPER` is unnecessary.
  *
  * References:
  * - libuv reaps its own children by pid on SIGCHLD (`uv__wait_children`):
@@ -42,7 +40,6 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { dlopen, FFIType, ptr } from "bun:ffi";
 
-import { getConfigReadOnly } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("orphan-reaper");
@@ -192,22 +189,9 @@ function reapScan(): void {
   }
 }
 
-/**
- * Read the opt-in gate from workspace config (`daemon.reapOrphanedSubprocesses`),
- * tolerating a missing or malformed config so startup never fails on it.
- */
-function isReaperEnabled(): boolean {
-  try {
-    return getConfigReadOnly().daemon.reapOrphanedSubprocesses;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Start the periodic orphan reaper. No-op unless the daemon is PID 1 on Linux
- * (otherwise reparented orphans are reaped by the real init) and the
- * `daemon.reapOrphanedSubprocesses` config gate is enabled.
+ * (otherwise reparented orphans are reaped by the real init).
  */
 export function startOrphanReaper(): void {
   if (scanTimer) return;
@@ -218,12 +202,6 @@ export function startOrphanReaper(): void {
     );
     return;
   }
-  if (!isReaperEnabled()) {
-    log.info(
-      "Orphan reaper not started: daemon.reapOrphanedSubprocesses is disabled",
-    );
-    return;
-  }
   if (!initWaitpid()) return;
   seenLastScan = new Set();
   scanTimer = setInterval(reapScan, SCAN_INTERVAL_MS);

package/src/daemon/server.ts

@@ -19,7 +19,6 @@ import {
   publishAvatarChanged,
   publishConfigChanged,
   publishIdentityChanged,
-  publishIdentityIntroChanged,
   publishSoundsConfigUpdated,
 } from "../runtime/sync/resource-sync-events.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
@@ -193,14 +192,6 @@ export class DaemonServer {
     }
   }
 
-  private broadcastIdentityIntroChanged(): void {
-    try {
-      publishIdentityIntroChanged();
-    } catch (err) {
-      log.error({ err }, "Failed to broadcast identity intro change");
-    }
-  }
-
   /** Best-effort sync of the IDENTITY.md name to the platform record. */
   private syncIdentityToPlatform(): void {
     try {
@@ -313,7 +304,6 @@ export class DaemonServer {
       () => this.broadcastAvatarUpdated(),
       () => this.broadcastConfigChanged(),
       () => refreshSkillCapabilityMemories(getConfig()),
-      () => this.broadcastIdentityIntroChanged(),
     );
 
     this.syncIdentityToPlatform();

package/src/daemon/tool-setup-types.ts

@@ -88,6 +88,10 @@ export interface ToolSetupContext extends SurfaceConversationContext {
   taskRunId?: string;
   /** Guardian runtime context for the conversation — trustClass is propagated into ToolContext for control-plane policy enforcement. */
   trustContext?: TrustContext;
+  /** Per-turn trust snapshot, captured at turn start. Preferred over the live
+   *  `trustContext` for mid-turn trust decisions (tool approval, control-plane
+   *  policy) so a concurrent mutation cannot elevate the in-flight turn. */
+  currentTurnTrustContext?: TrustContext;
   /** Voice/call session ID, if the conversation originates from a call. Propagated into ToolContext for scoped grant consumption. */
   callSessionId?: string;
   /** The interface ID of the connected client driving the current turn (e.g. "macos", "chrome-extension"). Propagated into ToolContext for browser backend selection. */

package/src/daemon/trust-context.ts

@@ -13,7 +13,7 @@ export interface TrustContext {
   /** Channel through which the inbound message arrived. */
   sourceChannel: ChannelId;
   /** Trust classification -- see {@link TrustClass} for semantics. */
-  trustClass: "guardian" | "trusted_contact" | "unknown";
+  trustClass: TrustClass;
   /** Chat/conversation ID for delivering guardian notifications. */
   guardianChatId?: string;
   /** Canonical external user ID of the guardian for this (assistant, channel) binding. */

package/src/daemon/wake-conversation-ops.ts

@@ -147,6 +147,7 @@ function translateAgentEventToServerMessage(
     case "compaction_completed":
     case "history_stripped":
     case "agent_loop_exit":
+    case "system_prompt_changed":
       return null;
     case "llm_call_started":
       // The wake path persists its assistant tail via

package/src/events/tool-audit-listener.ts

@@ -1,8 +1,8 @@
-import { getConfig } from "../config/loader.js";
 import {
   recordToolInvocation,
   type ToolInvocationRecord,
 } from "../memory/tool-usage-store.js";
+import { getCachedShareAnalytics } from "../platform/consent-cache.js";
 import { redactJsonStringLeaves } from "../security/redact-json.js";
 import { redactSecrets } from "../security/secret-scanner.js";
 import {
@@ -168,7 +168,7 @@ function telemetryColumns(
   rawInput: string,
   resultBytes: number,
 ): TelemetryColumns {
-  if (!getConfig().collectUsageData) return NULL_TELEMETRY_COLUMNS;
+  if (!getCachedShareAnalytics()) return NULL_TELEMETRY_COLUMNS;
   return {
     argBytes: event.inputBytes ?? Buffer.byteLength(rawInput, "utf8"),
     resultBytes,

package/src/home/feed-source-enrichment.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "bun:test";
+
+import { type FeedItem } from "../api/responses/home.js";
+import {
+  classifyConversationSource,
+  enrichFeedItemsWithSource,
+  type FeedSourceEnrichmentDeps,
+} from "./feed-source-enrichment.js";
+
+function makeItem(partial: Partial<FeedItem> & Pick<FeedItem, "id">): FeedItem {
+  return {
+    type: "notification",
+    priority: 50,
+    summary: "summary",
+    timestamp: "2026-06-18T00:00:00.000Z",
+    createdAt: "2026-06-18T00:00:00.000Z",
+    status: "new",
+    ...partial,
+  };
+}
+
+describe("classifyConversationSource", () => {
+  it("maps each known producer source to its coarse type", () => {
+    expect(classifyConversationSource("heartbeat")).toBe("heartbeat");
+    expect(classifyConversationSource("memory-retrospective")).toBe(
+      "memory_consolidation",
+    );
+    expect(classifyConversationSource("memory-retrospective-fork")).toBe(
+      "memory_consolidation",
+    );
+    expect(classifyConversationSource("schedule")).toBe("schedule");
+    expect(classifyConversationSource("auto-analysis")).toBe("auto_analysis");
+    expect(classifyConversationSource("user")).toBe("user");
+    expect(classifyConversationSource("home-feed")).toBe("user");
+  });
+
+  it("falls through to 'other' for unknown / paired-delivery / empty sources", () => {
+    expect(classifyConversationSource("notification")).toBe("other");
+    expect(classifyConversationSource("something-else")).toBe("other");
+    expect(classifyConversationSource(null)).toBe("other");
+    expect(classifyConversationSource(undefined)).toBe("other");
+  });
+});
+
+describe("enrichFeedItemsWithSource", () => {
+  const deps = (
+    conv: Record<string, { source: string; scheduleJobId: string | null }>,
+    schedules: Record<string, string> = {},
+  ): FeedSourceEnrichmentDeps => ({
+    getConversationRow: (id) => conv[id] ?? null,
+    getScheduleName: (id) => schedules[id] ?? null,
+  });
+
+  it("classifies a heartbeat item with a static label", () => {
+    const [item] = enrichFeedItemsWithSource(
+      [makeItem({ id: "n1", conversationId: "c1" })],
+      deps({ c1: { source: "heartbeat", scheduleJobId: null } }),
+    );
+    expect(item.sourceType).toBe("heartbeat");
+    expect(item.sourceKey).toBe("heartbeat");
+    expect(item.sourceLabel).toBe("Heartbeat");
+  });
+
+  it("classifies a memory-consolidation item", () => {
+    const [item] = enrichFeedItemsWithSource(
+      [makeItem({ id: "n2", conversationId: "c2" })],
+      deps({ c2: { source: "memory-retrospective", scheduleJobId: null } }),
+    );
+    expect(item.sourceType).toBe("memory_consolidation");
+    expect(item.sourceKey).toBe("memory_consolidation");
+    expect(item.sourceLabel).toBe("Memory consolidation");
+  });
+
+  it("gives distinct keys and names to two different schedules", () => {
+    const [a, b] = enrichFeedItemsWithSource(
+      [
+        makeItem({ id: "n3", conversationId: "cA" }),
+        makeItem({ id: "n4", conversationId: "cB" }),
+      ],
+      deps(
+        {
+          cA: { source: "schedule", scheduleJobId: "sched-A" },
+          cB: { source: "schedule", scheduleJobId: "sched-B" },
+        },
+        { "sched-A": "Morning digest", "sched-B": "Evening recap" },
+      ),
+    );
+    expect(a.sourceType).toBe("schedule");
+    expect(a.sourceKey).toBe("schedule:sched-A");
+    expect(a.sourceLabel).toBe("Morning digest");
+    // scheduleId recovered from the conversation row is surfaced in metadata.
+    expect(a.metadata?.scheduleId).toBe("sched-A");
+
+    expect(b.sourceKey).toBe("schedule:sched-B");
+    expect(b.sourceLabel).toBe("Evening recap");
+  });
+
+  it("prefers an explicit metadata.scheduleId over the conversation row", () => {
+    const [item] = enrichFeedItemsWithSource(
+      [
+        makeItem({
+          id: "n5",
+          conversationId: "cX",
+          metadata: { scheduleId: "from-payload" },
+        }),
+      ],
+      deps(
+        { cX: { source: "schedule", scheduleJobId: "from-row" } },
+        { "from-payload": "Payload schedule" },
+      ),
+    );
+    expect(item.sourceKey).toBe("schedule:from-payload");
+    expect(item.sourceLabel).toBe("Payload schedule");
+  });
+
+  it("labels a schedule with no resolvable name as 'Scheduled'", () => {
+    const [item] = enrichFeedItemsWithSource(
+      [makeItem({ id: "n6", conversationId: "cY" })],
+      deps({ cY: { source: "schedule", scheduleJobId: "gone" } }),
+    );
+    expect(item.sourceKey).toBe("schedule:gone");
+    expect(item.sourceLabel).toBe("Scheduled");
+  });
+
+  it("classifies items with no source conversation as 'other'", () => {
+    const [item] = enrichFeedItemsWithSource(
+      [makeItem({ id: "n7" })],
+      deps({}),
+    );
+    expect(item.sourceType).toBe("other");
+    expect(item.sourceKey).toBe("other");
+    expect(item.sourceLabel).toBe("Other");
+  });
+
+  it("resolves each distinct conversation at most once", () => {
+    const calls: string[] = [];
+    enrichFeedItemsWithSource(
+      [
+        makeItem({ id: "n8", conversationId: "dup" }),
+        makeItem({ id: "n9", conversationId: "dup" }),
+      ],
+      {
+        getConversationRow: (id) => {
+          calls.push(id);
+          return { source: "heartbeat", scheduleJobId: null };
+        },
+      },
+    );
+    expect(calls).toEqual(["dup"]);
+  });
+});