@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/runtime/__tests__/agent-wake.test.ts

@@ -7,7 +7,7 @@
  * double typed as `Conversation` (`makeWakeConversation`) that stubs only the
  * handful of members the wake touches — `getMessages`, `messages.push`,
  * `isProcessing`/`setProcessing`/`waitForIdle`, `currentTurnTrustContext`,
- * `setSubagentAllowedTools`, `drainQueue`, `maybeCompact`,
+ * `setSubagentAllowedTools`, `kickDrainQueue`, `maybeCompact`,
  * `contextWindowManager.estimateInputTokens`, and a scripted `agentLoop.run()`.
  *
  * The wake's side effects flow through the daemon boundary, so the
@@ -62,7 +62,7 @@ interface WakeConversationProbe {
   processingToggles: boolean[];
   /** Tail messages persisted via `addMessage`, in call order. */
   persistedTailCalls: Message[];
-  /** Number of times `drainQueue` was invoked. */
+  /** Number of times `kickDrainQueue` was invoked. */
   drainQueueCalls: number;
   /**
    * Cross-hook call sequence tag. Each push/persist/drain (and the
@@ -71,7 +71,7 @@ interface WakeConversationProbe {
    */
   callSequence: string[];
   /**
-   * Snapshot of the processing flag at the moment `drainQueue` was
+   * Snapshot of the processing flag at the moment `kickDrainQueue` was
    * invoked. Lets tests prove drain ran AFTER setProcessing(false),
    * rather than just inferring it from the order of recorded toggles.
    */
@@ -380,7 +380,7 @@ function makeWakeConversation(options: {
   scriptedTail?: Message[];
   scriptedEvents?: AgentEvent[];
   isProcessing?: boolean;
-  /** When true, omit `drainQueue` so we can verify the wake handles its absence. */
+  /** When true, omit `kickDrainQueue` so we can verify the wake handles its absence. */
   omitDrainQueue?: boolean;
   initialAllowedTools?: Set<string>;
   /** Replaces the default scripted `agentLoop.run` body entirely. */
@@ -471,7 +471,7 @@ function makeWakeConversation(options: {
 
   const runBody = options.runImpl ?? defaultRun;
 
-  const drainQueue = options.omitDrainQueue
+  const kickDrainQueue = options.omitDrainQueue
     ? undefined
     : async () => {
         probe.drainQueueCalls += 1;
@@ -597,7 +597,7 @@ function makeWakeConversation(options: {
     },
     buildCurrentSystemPrompt: () => "mock-system-prompt",
     modelOverride: undefined,
-    ...(drainQueue ? { drainQueue } : {}),
+    ...(kickDrainQueue ? { kickDrainQueue } : {}),
   };
 
   return conversation as unknown as WakeConversation;
@@ -2297,11 +2297,11 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.persistedTailCalls).toHaveLength(0);
   });
 
-  test("drainQueue is called in finally after a successful run", async () => {
+  test("kickDrainQueue is called in finally after a successful run", async () => {
     // Verifies Gap 1 fix: messages queued during a wake (because the
     // wake set `processing = true`) must be picked up after the wake
     // completes. Mirrors the canonical user-turn `finally` path which
-    // sets `processing = false` then calls `drainQueue`.
+    // sets `processing = false` then calls `kickDrainQueue`.
     const conversation = makeWakeConversation({
       baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
       scriptedAssistant: {
@@ -2333,7 +2333,7 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.isProcessing()).toBe(false);
   });
 
-  test("drainQueue is called in finally even when the agent loop throws", async () => {
+  test("kickDrainQueue is called in finally even when the agent loop throws", async () => {
     // Verifies the drain is in the finally block, not just on success.
     // A wake that crashes mid-run must still flush queued messages —
     // otherwise a transient LLM error strands every concurrent send.
@@ -2361,7 +2361,7 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.processingToggles).toEqual([true, false]);
   });
 
-  test("missing drainQueue hook is tolerated (no-op fallback)", async () => {
+  test("missing kickDrainQueue hook is tolerated (no-op fallback)", async () => {
     // The hook is intentionally optional so test stubs without a queue
     // can omit it. Production daemon always wires it.
     const conversation = makeWakeConversation({
@@ -2387,7 +2387,7 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.drainQueueCalls).toBe(0);
   });
 
-  test("drainQueue rejection does not propagate from the wake", async () => {
+  test("kickDrainQueue rejection does not propagate from the wake", async () => {
     // Defense in depth: if the queue drain throws (e.g. a poisoned
     // message), the wake itself must still resolve normally — the
     // drain failure is logged but never surfaced.
@@ -2398,7 +2398,7 @@ describe("wakeAgentForOpportunity", () => {
         content: [{ type: "text", text: "reply" }],
       },
     });
-    conversation.drainQueue = async () => {
+    conversation.kickDrainQueue = async () => {
       throw new Error("drain blew up");
     };
 
@@ -2461,7 +2461,7 @@ describe("wakeAgentForOpportunity", () => {
   });
 
   test(
-    "tail messages are pushed and persisted BEFORE drainQueue runs " +
+    "tail messages are pushed and persisted BEFORE the queue drain runs " +
       "(so dequeued turns see updated history)",
     async () => {
       // Locks in the round-3 fix: a user message queued during the wake
@@ -2474,7 +2474,7 @@ describe("wakeAgentForOpportunity", () => {
       //
       // Mirrors the canonical user-turn pattern in
       // conversation-agent-loop.ts: messages updated →
-      // processing=false → drainQueue.
+      // processing=false → kickDrainQueue.
       const firstAssistant: Message = {
         role: "assistant",
         content: [
@@ -2536,13 +2536,13 @@ describe("wakeAgentForOpportunity", () => {
   );
 
   test(
-    "silent no-op: drainQueue still runs (in finally) but nothing is " +
+    "silent no-op: the queue drain still runs (in finally) but nothing is " +
       "pushed, persisted, or emitted",
     async () => {
       // The wake's silent-no-op semantics must be preserved by the
       // round-3 reordering: an empty assistant reply produces no
       // visible text and no tool calls, so no push/persist/emit should
-      // happen. drainQueue must still run in the finally block so a
+      // happen. The queue drain must still run in the finally block so a
       // racy queued message is not stranded.
       const conversation = makeWakeConversation({
         baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -96,8 +96,6 @@ mock.module("../pre-first-message-gate.js", () => ({
 
 // Import after mocks are in place.
 const { runBackgroundJob } = await import("../background-job-runner.js");
-const { bufferIfDeferred, resetDeferredForTest } =
-  await import("../../notifications/deferred-emit.js");
 
 // ── Shared fixtures ──────────────────────────────────────────────────
 
@@ -125,7 +123,6 @@ beforeEach(() => {
   processMessageCalls.length = 0;
   emitCalls.length = 0;
   addMessageCalls.length = 0;
-  resetDeferredForTest();
   preFirstMessageGateOpen = true;
   processMessageImpl = async () => ({ messageId: "msg-1" });
   emitImpl = async () => ({
@@ -290,22 +287,6 @@ describe("runBackgroundJob", () => {
     ).toBe("model_provider");
   });
 
-  test("non-throwing turn failure with deferNotifications drops buffered notifications", async () => {
-    processMessageImpl = async () => ({
-      messageId: "msg-failed-turn",
-      turnFailure: { failureCode: "provider_error" },
-    });
-
-    const result = await runBackgroundJob(
-      baseOpts({ deferNotifications: true }),
-    );
-
-    expect(result.ok).toBe(false);
-    // Only the runner's failure signal emits — no committed "success" signal.
-    expect(emitCalls).toHaveLength(1);
-    expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-  });
-
   test("timeout: returns ok=false with errorKind=timeout and emits activity.failed", async () => {
     // Never resolve — force timeout to win the race.
     processMessageImpl = () => new Promise(() => {});
@@ -464,129 +445,4 @@ describe("runBackgroundJob", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
   });
-
-  describe("deferNotifications", () => {
-    function buildSkillNotificationParams(message: string) {
-      return {
-        sourceEventName: "assistant.share",
-        sourceChannel: "assistant_tool" as const,
-        sourceContextId: "skill-ctx",
-        contextPayload: { requestedMessage: message },
-        attentionHints: {
-          requiresAction: false,
-          urgency: "low" as const,
-          isAsyncBackground: false,
-          visibleInSourceNow: false,
-        },
-      };
-    }
-
-    test("success path commits buffered in-band notifications", async () => {
-      processMessageImpl = async () => {
-        // Stand in for the IPC route's bufferIfDeferred call when the model
-        // invokes `notifications send` mid-turn.
-        const buffered = bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("all green"),
-        );
-        expect(buffered).not.toBeNull();
-        expect(buffered!.dispatched).toBe(false);
-        return { messageId: "msg-success" };
-      };
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true }),
-      );
-
-      expect(result.ok).toBe(true);
-      // Commit flushed the buffered notification through emitNotificationSignal.
-      const successEmits = emitCalls.filter(
-        (e) => e.sourceEventName !== "activity.failed",
-      );
-      expect(successEmits).toHaveLength(1);
-      expect(successEmits[0].sourceEventName).toBe("assistant.share");
-    });
-
-    // Regression for the PR #31216 Codex P1 finding: a heartbeat that calls
-    // the notifications skill and then times out must not leave a "success"
-    // notification standing alongside the runner's `activity.failed` emit.
-    test("timeout drops buffered in-band notifications; only activity.failed emits", async () => {
-      processMessageImpl = () => {
-        bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("premature success"),
-        );
-        return new Promise(() => {});
-      };
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true, timeoutMs: 30 }),
-      );
-
-      expect(result.ok).toBe(false);
-      expect(result.errorKind).toBe("timeout");
-      // Only the runner's failure signal makes it out — the buffered
-      // "success" notification is discarded.
-      expect(emitCalls).toHaveLength(1);
-      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-    });
-
-    test("thrown exception also drops buffered notifications", async () => {
-      processMessageImpl = async () => {
-        bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("doomed"),
-        );
-        throw new Error("kaboom");
-      };
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true }),
-      );
-
-      expect(result.ok).toBe(false);
-      expect(emitCalls).toHaveLength(1);
-      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-    });
-
-    // Regression: after timeout, `processMessage` keeps running and may
-    // emit a late skill call. The tombstone must swallow it instead of
-    // letting it bypass the buffer and reach the dispatch pipeline.
-    test("late skill call after timeout is swallowed by the tombstone", async () => {
-      processMessageImpl = () => new Promise(() => {});
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true, timeoutMs: 20 }),
-      );
-      expect(result.ok).toBe(false);
-
-      const late = bufferIfDeferred(
-        STUB_CONVERSATION_ID,
-        buildSkillNotificationParams("post-timeout"),
-      );
-      expect(late).not.toBeNull();
-      expect(late!.dispatched).toBe(false);
-      expect(late!.reason).toMatch(/did not complete/);
-
-      // Only the runner's failure signal made it out.
-      expect(emitCalls).toHaveLength(1);
-      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-    });
-
-    test("without deferNotifications, bufferIfDeferred is a no-op", async () => {
-      processMessageImpl = async () => {
-        const buffered = bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("immediate"),
-        );
-        // Buffer was never armed, so the call returns null and the IPC
-        // handler would emit directly.
-        expect(buffered).toBeNull();
-        return { messageId: "msg-success" };
-      };
-
-      const result = await runBackgroundJob(baseOpts());
-      expect(result.ok).toBe(true);
-    });
-  });
 });

package/src/runtime/__tests__/desktop-presence.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Tests for the desktop presence policy.
+ *
+ * The invariant under test is fail-open: only a fresh `active` report from a
+ * `macos` client answers `true`. Every other shape (stale, idle, away, no
+ * presence, wrong interface, no clients, hub throw) answers `false` so the
+ * push is sent. Scoping the read to an actor principal narrows what counts as
+ * attendance, so it can only ever turn a `true` into a `false`.
+ */
+
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+
+import {
+  clearHubClients,
+  registerHubClient,
+  type RegisterHubClientArgs,
+} from "../../__tests__/helpers/hub-clients.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
+import {
+  isDesktopAttended,
+  PRESENCE_STALE_AFTER_MS,
+} from "../desktop-presence.js";
+
+// ── Test helpers ──────────────────────────────────────────────────────────
+
+/** A `now` far enough past every report to push all of them out of the window. */
+function afterStaleness(): Date {
+  return new Date(Date.now() + PRESENCE_STALE_AFTER_MS + 1_000);
+}
+
+/** The policy reads the process singleton, so every client registers there. */
+function registerClient(args: Omit<RegisterHubClientArgs, "hub">): void {
+  registerHubClient({ ...args, hub: assistantEventHub });
+}
+
+afterEach(() => {
+  clearHubClients(assistantEventHub);
+});
+
+// ── Tests ─────────────────────────────────────────────────────────────────
+
+describe("isDesktopAttended", () => {
+  test("fresh active macos client is attended", () => {
+    registerClient({ clientId: "mac-1", presence: "active" });
+    expect(isDesktopAttended()).toBe(true);
+  });
+
+  test("active report older than the staleness bound is not attended", () => {
+    registerClient({ clientId: "mac-1", presence: "active" });
+    expect(isDesktopAttended({ now: afterStaleness() })).toBe(false);
+  });
+
+  test("idle is not attended", () => {
+    registerClient({ clientId: "mac-1", presence: "idle" });
+    expect(isDesktopAttended()).toBe(false);
+  });
+
+  test("away is not attended", () => {
+    registerClient({ clientId: "mac-1", presence: "away" });
+    expect(isDesktopAttended()).toBe(false);
+  });
+
+  test("client that never reported presence is not attended", () => {
+    registerClient({ clientId: "mac-1" });
+    expect(isDesktopAttended()).toBe(false);
+  });
+
+  test("active web client does not count as desktop presence", () => {
+    registerClient({
+      clientId: "web-1",
+      interfaceId: "web",
+      presence: "active",
+    });
+    expect(isDesktopAttended()).toBe(false);
+  });
+
+  test("no connected clients is not attended", () => {
+    expect(isDesktopAttended()).toBe(false);
+  });
+
+  test("a hub read that throws is not attended", () => {
+    const spy = spyOn(
+      assistantEventHub,
+      "listClientsByInterface",
+    ).mockImplementation(() => {
+      throw new Error("hub exploded");
+    });
+    try {
+      expect(isDesktopAttended()).toBe(false);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("one active macos client among several is enough", () => {
+    registerClient({ clientId: "mac-1", presence: "away" });
+    registerClient({ clientId: "mac-2", presence: "active" });
+    expect(isDesktopAttended()).toBe(true);
+  });
+});
+
+describe("isDesktopAttended scoped to an actor principal", () => {
+  test("matching actor principal is attended", () => {
+    registerClient({
+      clientId: "mac-1",
+      presence: "active",
+      actorPrincipalId: "actor-a",
+    });
+    expect(isDesktopAttended({ actorPrincipalId: "actor-a" })).toBe(true);
+  });
+
+  test("another actor's attended mac does not count", () => {
+    registerClient({
+      clientId: "mac-1",
+      presence: "active",
+      actorPrincipalId: "actor-a",
+    });
+    expect(isDesktopAttended({ actorPrincipalId: "actor-b" })).toBe(false);
+  });
+
+  test("client with no principal does not match a supplied principal", () => {
+    registerClient({ clientId: "mac-1", presence: "active" });
+    expect(isDesktopAttended({ actorPrincipalId: "actor-a" })).toBe(false);
+  });
+
+  test("omitting the principal counts any attended macos client", () => {
+    registerClient({
+      clientId: "mac-1",
+      presence: "active",
+      actorPrincipalId: "actor-a",
+    });
+    expect(isDesktopAttended()).toBe(true);
+  });
+
+  test("target actor's stale report is not attended", () => {
+    registerClient({
+      clientId: "mac-1",
+      presence: "active",
+      actorPrincipalId: "actor-a",
+    });
+    expect(
+      isDesktopAttended({
+        actorPrincipalId: "actor-a",
+        now: afterStaleness(),
+      }),
+    ).toBe(false);
+  });
+
+  test("only the non-target actor is active among several clients", () => {
+    registerClient({
+      clientId: "mac-1",
+      presence: "active",
+      actorPrincipalId: "actor-a",
+    });
+    registerClient({
+      clientId: "mac-2",
+      presence: "away",
+      actorPrincipalId: "actor-b",
+    });
+    expect(isDesktopAttended({ actorPrincipalId: "actor-b" })).toBe(false);
+  });
+});

package/src/runtime/agent-wake.ts

@@ -86,6 +86,7 @@ import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { conversationSupportsDynamicUi } from "../daemon/channel-ui-capability.js";
 import type { Conversation } from "../daemon/conversation.js";
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
 import { recordUsage } from "../daemon/conversation-usage.js";
 import { getDiskPressureStatus } from "../daemon/disk-pressure-guard.js";
 import {
@@ -534,6 +535,47 @@ async function defaultResolveTarget(
   }
 }
 
+// ── Queue drain kick ──────────────────────────────────────────────────
+
+/**
+ * The queue-drain surface the wake kicks on its way out.
+ *
+ * The hook is optional because the wake runs against whatever
+ * {@link WakeDeps.resolveTarget} hands it, which in tests is a partial
+ * conversation double. Production `Conversation` always provides it.
+ */
+interface WakeDrainTarget {
+  kickDrainQueue?: (
+    reason?: QueueDrainReason,
+    origin?: string,
+  ) => Promise<void>;
+}
+
+/**
+ * Drain the target's message queue once the wake has released the
+ * conversation.
+ *
+ * `Conversation.kickDrainQueue` retries a failed drain once and notifies the
+ * queued senders when the retry also fails, so a stalled wake-tail drain is
+ * visible instead of silently stranding the queue, and it never rejects. An
+ * injected target can still omit the hook or reject from it, and neither may
+ * fail the wake, whose own work is already complete by this point.
+ */
+async function kickWakeDrainQueue(
+  conversation: WakeDrainTarget,
+  origin: string,
+  logContext: { conversationId: string; source: string },
+): Promise<void> {
+  try {
+    await conversation.kickDrainQueue?.("loop_complete", origin);
+  } catch (err) {
+    log.warn(
+      { ...logContext, err },
+      "agent-wake: kickDrainQueue threw; continuing",
+    );
+  }
+}
+
 // ── Per-conversation single-flight lock ───────────────────────────────
 //
 // When a wake arrives and another run is in flight for the same
@@ -813,7 +855,7 @@ export async function wakeAgentForOpportunity(
     // Apply the caller's persona override for the duration of the run. The
     // prompt is built once before `agentLoop.run()` (via
     // `conversation.buildCurrentSystemPrompt()`), which reads this field;
-    // cleared (below, before drainQueue) so a queued user turn never builds
+    // cleared (below, before the queue drain) so a queued user turn never builds
     // its prompt under the wake's override. Assigned only AFTER the
     // profile/config reads above — those can throw, and they run before the
     // try/finally that clears the override, so an earlier assignment would
@@ -1411,10 +1453,14 @@ export async function wakeAgentForOpportunity(
       // user turn or a later background read never inherits the wake's stamps.
       const priorCallSite = conversation.currentCallSite;
       const priorTurnOverrideProfile = conversation.currentTurnOverrideProfile;
+      const priorTurnCronRunId = conversation.currentTurnCronRunId;
       const priorHasNoClient = conversation.hasNoClient;
       const priorTurnTrust = conversation.currentTurnTrustContext;
       conversation.currentCallSite = callSite;
       conversation.currentTurnOverrideProfile = overrideProfile;
+      // Same reason as the stamps above: a wake triggered by a schedule firing
+      // delegates work to subagents whose usage must attribute to that firing.
+      conversation.currentTurnCronRunId = opts.cronRunId ?? null;
       if (opts.clientless) {
         conversation.hasNoClient = true;
       }
@@ -1503,6 +1549,7 @@ export async function wakeAgentForOpportunity(
         // at the start of the next normal turn regardless.)
         conversation.currentCallSite = priorCallSite;
         conversation.currentTurnOverrideProfile = priorTurnOverrideProfile;
+        conversation.currentTurnCronRunId = priorTurnCronRunId;
         conversation.hasNoClient = priorHasNoClient;
         conversation.currentTurnTrustContext = priorTurnTrust;
       }
@@ -1519,7 +1566,7 @@ export async function wakeAgentForOpportunity(
       // Run completed cleanly. The canonical user-turn pattern
       // (conversation-agent-loop.ts:1860, 2106-2126) updates
       // `ctx.messages` first, then clears the flag via `ctx.setProcessing(false)`, then
-      // calls `ctx.drainQueue(...)`. We mirror that order so a message
+      // calls `ctx.kickDrainQueue(...)`. We mirror that order so a message
       // queued during the wake dequeues against an already-updated
       // history — otherwise `drainSingleMessage` reads `ctx.messages`
       // mid-tail and writes a DB row that lands out of chronological
@@ -1590,7 +1637,7 @@ export async function wakeAgentForOpportunity(
         // Silent no-op: drop buffered events, push nothing, persist
         // nothing, emit nothing. (No checkpoint fired during the run
         // since checkpoints only fire after tool turns and there were
-        // none.) The finally still runs drainQueue so a racy queued
+        // none.) The finally still kicks the queue drain so a racy queued
         // message isn't stranded.
         return { invoked: true, producedToolCalls: false };
       }
@@ -1621,25 +1668,21 @@ export async function wakeAgentForOpportunity(
           "agent-wake: setProcessing(false) threw; continuing",
         );
       }
-      try {
-        await conversation.drainQueue();
-      } catch (err) {
-        log.warn(
-          { conversationId, source, err },
-          "agent-wake: drainQueue threw; continuing",
-        );
-      }
+      await kickWakeDrainQueue(conversation, "agent_wake_tail", {
+        conversationId,
+        source,
+      });
       drainedInTry = true;
 
       return { invoked: true, producedToolCalls };
     } finally {
       // Put the conversation's resting trust back on every exit path.
       restorePersistentWakeTrust();
-      // The success path (above) already called setProcessing(false)
-      // + drainQueue after tail persist. This catch-all handles the
-      // error and early-return paths where no tail was produced — those
-      // exit the try body before reaching the drain block, so
-      // `drainedInTry` is still false.
+      // The success path (above) already called setProcessing(false) and
+      // kicked the queue drain after tail persist. This catch-all handles the
+      // error and early-return paths where no tail was produced: those exit
+      // the try body before reaching the drain block, so `drainedInTry` is
+      // still false.
       if (!drainedInTry) {
         restoreWakeAllowedTools();
         clearWakePersonaOverride();
@@ -1651,14 +1694,10 @@ export async function wakeAgentForOpportunity(
             "agent-wake: setProcessing(false) threw; continuing",
           );
         }
-        try {
-          await conversation.drainQueue();
-        } catch (err) {
-          log.warn(
-            { conversationId, source, err },
-            "agent-wake: drainQueue threw; continuing",
-          );
-        }
+        await kickWakeDrainQueue(conversation, "agent_wake_cleanup", {
+          conversationId,
+          source,
+        });
       }
 
       const durationMs = nowFn() - startedAt;