@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/heartbeat/heartbeat-run-store.ts

@@ -1,4 +1,14 @@
-import { desc, eq, lt, sql } from "drizzle-orm";
+import {
+  and,
+  desc,
+  eq,
+  gt,
+  inArray,
+  isNotNull,
+  lt,
+  notInArray,
+  sql,
+} from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../persistence/db-connection.js";
@@ -25,7 +35,8 @@ export type HeartbeatSkipReason =
   | "overlap"
   | "pre_first_user_message"
   | "max_consecutive_runs"
-  | "max_daily_runs";
+  | "max_daily_runs"
+  | "quiesced";
 
 export interface HeartbeatRunRecord {
   id: string;
@@ -271,7 +282,19 @@ export function countRecentConsecutiveRuns(maxToCheck: number): number {
 }
 
 /**
- * List heartbeat runs ordered by `scheduledFor` descending.
+ * Statuses excluded from run history: scheduler bookkeeping rows, not runs.
+ * `pending` is the not-yet-fired next scheduled run (surfaced separately as
+ * "next run"), and `superseded` rows are pending rows replaced by a timer
+ * reset — a guardian message resets the heartbeat timer, so an active chat
+ * day leaves dozens of them behind without a single heartbeat firing.
+ */
+const BOOKKEEPING_STATUSES: HeartbeatRunStatus[] = ["pending", "superseded"];
+
+/**
+ * List heartbeat run history ordered by `scheduledFor` descending.
+ * Bookkeeping rows ({@link BOOKKEEPING_STATUSES}) are excluded — every
+ * returned row is a run that executed, was skipped by a guard (with its
+ * `skipReason`), or was missed while the daemon was down.
  * When `before` is set, only runs with `scheduledFor` strictly older than it
  * are returned (cursor for paginating into history).
  */
@@ -280,16 +303,70 @@ export function listHeartbeatRuns(
   before?: number,
 ): HeartbeatRunRecord[] {
   const db = getDb();
+  const historyOnly = notInArray(heartbeatRuns.status, BOOKKEEPING_STATUSES);
   const rows = db
     .select()
     .from(heartbeatRuns)
-    .where(before != null ? lt(heartbeatRuns.scheduledFor, before) : undefined)
+    .where(
+      before != null
+        ? and(lt(heartbeatRuns.scheduledFor, before), historyOnly)
+        : historyOnly,
+    )
     .orderBy(desc(heartbeatRuns.scheduledFor))
     .limit(limit)
     .all();
   return rows.map(parseRow);
 }
 
+/** Terminal statuses of runs that actually executed. */
+const EXECUTED_STATUSES: HeartbeatRunStatus[] = ["ok", "error", "timeout"];
+
+/**
+ * Epoch-ms timestamp of the most recent heartbeat run that actually executed
+ * (reached `ok`, `error`, or `timeout`), or null when none exists. Uses
+ * `finishedAt`, falling back to `startedAt` for rows finalized by a crash
+ * sweep without one.
+ */
+export function getLastHeartbeatRunAt(): number | null {
+  const db = getDb();
+  const row = db
+    .select({
+      lastRunAt: sql<
+        number | null
+      >`max(coalesce(${heartbeatRuns.finishedAt}, ${heartbeatRuns.startedAt}))`,
+    })
+    .from(heartbeatRuns)
+    .where(inArray(heartbeatRuns.status, EXECUTED_STATUSES))
+    .get();
+  return row?.lastRunAt ?? null;
+}
+
+/**
+ * Heartbeat runs currently `running`, capped to those started within
+ * `maxAgeMs`. The age bound matters: a run orphaned by a crash keeps its
+ * `running` status until a later boot's stale sweep relabels it, and an
+ * unbounded read would let that phantom row hold a drain open indefinitely.
+ */
+export function listRunningHeartbeatRuns(
+  maxAgeMs: number,
+): Array<{ runId: string; startedAt: number }> {
+  const db = getDb();
+  const cutoff = Date.now() - maxAgeMs;
+  return db
+    .select({ runId: heartbeatRuns.id, startedAt: heartbeatRuns.startedAt })
+    .from(heartbeatRuns)
+    .where(
+      and(
+        eq(heartbeatRuns.status, "running"),
+        isNotNull(heartbeatRuns.startedAt),
+        gt(heartbeatRuns.startedAt, cutoff),
+      ),
+    )
+    .orderBy(desc(heartbeatRuns.startedAt))
+    .limit(20)
+    .all() as Array<{ runId: string; startedAt: number }>;
+}
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------

package/src/heartbeat/heartbeat-service.ts

@@ -11,6 +11,7 @@ import {
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
+import { isLifecycleQuiesced } from "../persistence/lifecycle-quiesce.js";
 import {
   GUARDIAN_PERSONA_TEMPLATE,
   resolveGuardianPersona,
@@ -29,6 +30,7 @@ import {
   countCompletedHeartbeatRuns,
   countCompletedRunsToday,
   countRecentConsecutiveRuns,
+  getLastHeartbeatRunAt,
   insertPendingHeartbeatRun,
   markStaleRunningAsError,
   markStaleRunsAsMissed,
@@ -168,8 +170,23 @@ export class HeartbeatService {
     HeartbeatService.instance = this;
   }
 
-  /** Epoch-ms timestamp of the last completed heartbeat run. */
+  /**
+   * Epoch-ms timestamp of the last completed heartbeat run. The in-memory
+   * field only covers runs completed in this process's lifetime, so when it
+   * is unset the value is rehydrated from run history — a daemon restart
+   * must not blank "last run" while completed runs exist in the database.
+   */
   get lastRunAt(): number | null {
+    if (this._lastRunAt == null) {
+      try {
+        this._lastRunAt = getLastHeartbeatRunAt();
+      } catch (err) {
+        // DB unavailable (e.g. migrations still settling) — report unknown
+        // and retry on the next read.
+        log.debug({ err }, "Failed to read last heartbeat run from history");
+        return null;
+      }
+    }
     return this._lastRunAt;
   }
 
@@ -486,6 +503,20 @@ export class HeartbeatService {
       return false;
     }
 
+    // Drain guard: while a quiesce lease is active (a client is waiting for
+    // background work to finish before stopping the assistant), do not start
+    // new beats. Recorded as a skipped run so run history explains the gap.
+    if (!force && isLifecycleQuiesced()) {
+      log.info("Heartbeat skipped — quiesce lease active");
+      if (runId) {
+        skipHeartbeatRun(runId, "quiesced");
+      }
+      if (!this.cronMode) {
+        this.scheduleNextRun(config.intervalMs);
+      }
+      return false;
+    }
+
     // Warm-pool guard: skip heartbeats until the user has actually
     // interacted with the assistant. Heartbeats run the LLM against the
     // guardian persona, which doesn't exist in a fresh warm-pool image —

package/src/home/__tests__/feed-writer.test.ts

@@ -35,7 +35,9 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     // hub's real shape has more fields. Tests never call them.
     subscribe: () => () => {},
   },
-  broadcastMessage: async () => {},
+  broadcastMessage: (message: unknown, conversationId?: string) => {
+    void publishSpy({ message, conversationId });
+  },
 }));
 
 // Dynamic import so the module resolves after the mock above is in
@@ -717,11 +719,7 @@ describe("feed-writer", () => {
         }),
       );
 
-      const count = await bulkSetFeedItemStatus(
-        ["new"],
-        "seen",
-        ["n1", "n3"],
-      );
+      const count = await bulkSetFeedItemStatus(["new"], "seen", ["n1", "n3"]);
       expect(count).toBe(2);
 
       const decoded = readFileJson();
@@ -734,7 +732,9 @@ describe("feed-writer", () => {
     test("ids scope with no matching ids returns 0", async () => {
       await appendFeedItem(makeItem({ id: "n1", status: "new" }));
 
-      const count = await bulkSetFeedItemStatus(["new"], "seen", ["nonexistent"]);
+      const count = await bulkSetFeedItemStatus(["new"], "seen", [
+        "nonexistent",
+      ]);
       expect(count).toBe(0);
 
       const decoded = readFileJson();

package/src/home/__tests__/home-content-refresh.test.ts

@@ -26,6 +26,9 @@ mock.module("../suggested-prompts.js", () => ({
 const publishSpy = mock<(event: unknown) => Promise<void>>(async () => {});
 mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: publishSpy },
+  broadcastMessage: (message: unknown) => {
+    void publishSpy(message);
+  },
 }));
 
 mock.module("../../runtime/assistant-event.js", () => ({

package/src/home/__tests__/suggested-prompts.test.ts

@@ -61,6 +61,7 @@ mock.module("../../runtime/assistant-event.js", () => ({
 
 mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: async () => {} },
+  broadcastMessage: () => {},
 }));
 
 const { getSuggestedPrompts, refreshAssistantSuggestedPrompts } =

package/src/home/feed-writer.ts

@@ -37,8 +37,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { getDataDir } from "../util/platform.js";
 import {
@@ -523,15 +522,9 @@ function compareFeedItems(a: FeedItem, b: FeedItem): number {
  * writer coalescing loop.
  */
 function publishHomeFeedUpdated(updatedAt: string, newItemCount: number): void {
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "home_feed_updated",
-        updatedAt,
-        newItemCount,
-      }),
-    )
-    .catch((err) => {
-      log.warn({ err }, "Failed to publish home_feed_updated event");
-    });
+  broadcastMessage({
+    type: "home_feed_updated",
+    updatedAt,
+    newItemCount,
+  });
 }

package/src/home/home-content-refresh.ts

@@ -14,8 +14,7 @@
  * (4 hours each) bound how often a regeneration can happen.
  */
 
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { refreshPersonalizedGreeting } from "./home-greeting.js";
 import { refreshAssistantSuggestedPrompts } from "./suggested-prompts.js";
@@ -34,13 +33,11 @@ async function revalidateAll(): Promise<void> {
     return;
   }
 
-  await assistantEventHub.publish(
-    buildAssistantEvent({
-      type: "home_feed_updated",
-      updatedAt: new Date().toISOString(),
-      newItemCount: 0,
-    }),
-  );
+  broadcastMessage({
+    type: "home_feed_updated",
+    updatedAt: new Date().toISOString(),
+    newItemCount: 0,
+  });
 }
 
 /**

package/src/home/relationship-state-writer.ts

@@ -25,8 +25,7 @@ import { getGuardianDelivery } from "../contacts/guardian-delivery-reader.js";
 import { listConnections } from "../oauth/oauth-store.js";
 import { countConversations as countConversationsDb } from "../persistence/conversation-queries.js";
 import { resolveGuardianPersonaPath } from "../prompts/persona-resolver.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -316,16 +315,10 @@ export async function writeRelationshipState(): Promise<void> {
  * just landed on disk.
  */
 function publishRelationshipStateUpdated(updatedAt: string): void {
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "relationship_state_updated",
-        updatedAt,
-      }),
-    )
-    .catch((err) => {
-      log.warn({ err }, "Failed to publish relationship_state_updated event");
-    });
+  broadcastMessage({
+    type: "relationship_state_updated",
+    updatedAt,
+  });
 }
 
 /**

package/src/home/suggested-prompts-cache.ts

@@ -16,13 +16,9 @@ import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
 } from "../persistence/checkpoints.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { getLogger } from "../util/logger.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { SuggestedPrompt } from "./feed-types.js";
 
-const log = getLogger("suggested-prompts-cache");
-
 const LLM_CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
 
 const CHECKPOINT_KEY_JSON = "home:suggested_prompts:json";
@@ -74,18 +70,9 @@ export function invalidateAssistantSuggestedPromptsCache(): void {
   } catch {
     // Invalidation failure is non-fatal — the TTL still bounds staleness.
   }
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "home_feed_updated",
-        updatedAt: new Date().toISOString(),
-        newItemCount: 0,
-      }),
-    )
-    .catch((err) => {
-      log.warn(
-        { err },
-        "Failed to publish home_feed_updated after prompt cache invalidation",
-      );
-    });
+  broadcastMessage({
+    type: "home_feed_updated",
+    updatedAt: new Date().toISOString(),
+    newItemCount: 0,
+  });
 }

package/src/ipc/__tests__/events-publish-client.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Tests the side-process → daemon publish forwarder. It calls the daemon's
+ * `/events/publish` IPC route with the event envelope, and is best-effort: a
+ * transport failure is logged, never thrown.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantEventEnvelope } from "../../api/index.js";
+
+interface IpcCall {
+  method: string;
+  params?: Record<string, unknown>;
+}
+const ipcCalls: IpcCall[] = [];
+let ipcResult: { ok: boolean; error?: string } = { ok: true };
+
+mock.module("../cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    ipcCalls.push({ method, params });
+    return ipcResult;
+  },
+}));
+
+const { EVENTS_PUBLISH_IPC_METHOD, forwardEventPublishToDaemon } =
+  await import("../events-publish-client.js");
+
+function event(): AssistantEventEnvelope {
+  return {
+    id: "e1",
+    conversationId: "c1",
+    emittedAt: "2026-01-01T00:00:00.000Z",
+    message: {
+      type: "sync_changed",
+    } as unknown as AssistantEventEnvelope["message"],
+  };
+}
+
+beforeEach(() => {
+  ipcCalls.length = 0;
+  ipcResult = { ok: true };
+});
+
+describe("forwardEventPublishToDaemon", () => {
+  test("calls the /events/publish route with the event (and options when present)", async () => {
+    await forwardEventPublishToDaemon(event(), { excludeClientId: "tab-1" });
+    expect(ipcCalls).toHaveLength(1);
+    expect(ipcCalls[0].method).toBe(EVENTS_PUBLISH_IPC_METHOD);
+    expect(ipcCalls[0].params).toEqual({
+      body: { event: event(), options: { excludeClientId: "tab-1" } },
+    });
+  });
+
+  test("passes undefined options through when none are given", async () => {
+    await forwardEventPublishToDaemon(event(), undefined);
+    expect(ipcCalls[0].params).toEqual({
+      body: { event: event(), options: undefined },
+    });
+  });
+
+  test("does not throw when the IPC transport fails", async () => {
+    ipcResult = { ok: false, error: "connect failed" };
+    await expect(
+      forwardEventPublishToDaemon(event(), undefined),
+    ).resolves.toBeUndefined();
+  });
+});

package/src/ipc/events-publish-client.ts

@@ -0,0 +1,44 @@
+/**
+ * Client transport for forwarding an event publish to the daemon.
+ *
+ * The daemon owns the event hub and the client connections it fans out to. A
+ * side process (a sidecar worker, the route host) that publishes to its *own*
+ * in-process hub reaches no SSE subscriber, so it must hand the event to the
+ * daemon instead. This module is that hand-off: it calls the daemon's
+ * `/events/publish` IPC route ({@link EVENTS_PUBLISH_IPC_METHOD}), which
+ * republishes the event on the daemon's real hub.
+ *
+ * The method-name constant lives here (not in the route module) so callers can
+ * import it without pulling in the route handler's dependency graph.
+ */
+
+import type { AssistantEventEnvelope } from "../api/index.js";
+import type { AssistantEventPublishOptions } from "../runtime/assistant-event-publish-options.js";
+import { getLogger } from "../util/logger.js";
+import { cliIpcCall } from "./cli-client.js";
+
+const log = getLogger("events-publish-client");
+
+/** IPC method name — the raw publish transport other processes call. */
+export const EVENTS_PUBLISH_IPC_METHOD = "/events/publish";
+
+/**
+ * Forward an event publish to the daemon over IPC. Best-effort: a transport
+ * failure is logged, not thrown — a dropped UI-invalidation must never surface
+ * as a handler error (mirroring the local hub, whose subscriber failures are
+ * isolated from the publisher).
+ */
+export async function forwardEventPublishToDaemon(
+  event: AssistantEventEnvelope,
+  options: AssistantEventPublishOptions | undefined,
+): Promise<void> {
+  const result = await cliIpcCall(EVENTS_PUBLISH_IPC_METHOD, {
+    body: { event, options },
+  });
+  if (!result.ok) {
+    log.warn(
+      { err: result.error, eventType: event.message?.type },
+      "Failed to forward event publish to the daemon",
+    );
+  }
+}

package/src/ipc/routes/__tests__/conversation-sync-ipc-routes.test.ts

@@ -29,13 +29,13 @@ mock.module("../../../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
+import type { AssistantEventEnvelope } from "../../../api/index.js";
 import type { EventHandlerState } from "../../../daemon/conversation-agent-loop-handlers.js";
 import { DB_MIGRATION_READINESS_EXEMPT_OPERATIONS } from "../../../daemon/daemon-readiness.js";
 import {
   registerInflightTurn,
   unregisterInflightTurn,
 } from "../../../daemon/inflight-turn-registry.js";
-import type { AssistantEvent } from "../../../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
   stampAndBuffer,
@@ -50,7 +50,7 @@ function stampEvent(): void {
   stampAndBuffer({
     conversationId: "conv-x",
     message: { type: "assistant_text_delta", text: "x" },
-  } as unknown as AssistantEvent);
+  } as unknown as AssistantEventEnvelope);
 }
 
 describe("conversation-sync IPC route", () => {

package/src/ipc/routes/__tests__/events-ipc-routes.test.ts

@@ -1,10 +1,8 @@
 import { afterEach, describe, expect, test } from "bun:test";
 
+import { EVENTS_PUBLISH_IPC_METHOD } from "../../../ipc/events-publish-client.js";
 import { assistantEventHub } from "../../../runtime/assistant-event-hub.js";
-import {
-  EVENTS_PUBLISH_IPC_METHOD,
-  handleEventsPublish,
-} from "../events-ipc-routes.js";
+import { handleEventsPublish } from "../events-ipc-routes.js";
 
 describe(`${EVENTS_PUBLISH_IPC_METHOD} IPC route`, () => {
   const disposers: Array<() => void> = [];
@@ -39,17 +37,48 @@ describe(`${EVENTS_PUBLISH_IPC_METHOD} IPC route`, () => {
   test("publishes a full event envelope onto the daemon hub", async () => {
     const received = subscribe();
 
+    const message = {
+      type: "generation_cancelled",
+      conversationId: "conv-events-test",
+    };
     const result = await handleEventsPublish({
-      body: { event: fullEvent({ type: "test_event", value: 42 }) },
+      body: { event: fullEvent(message) },
     });
 
     expect(result).toEqual({ ok: true });
     expect(received).toHaveLength(1);
     expect((received[0] as { id: string }).id).toBe("evt-1");
-    expect((received[0] as { message: unknown }).message).toEqual({
-      type: "test_event",
-      value: 42,
+    expect((received[0] as { message: unknown }).message).toEqual(message);
+  });
+
+  test("stamps a forwarded conversation-scoped event with a seq for replay", async () => {
+    const received = subscribe();
+
+    // A forwarded event arrives unstamped (the worker that produced it has seq
+    // stamping disabled). The daemon boundary must assign a `seq` so the event
+    // takes a slot in the SSE replay ring and reconnecting clients see it in
+    // order, rather than a gap.
+    const event = fullEvent({
+      type: "generation_cancelled",
+      conversationId: "conv-events-test",
     });
+    expect((event as { seq?: number }).seq).toBeUndefined();
+
+    await handleEventsPublish({ body: { event } });
+
+    expect(received).toHaveLength(1);
+    expect(typeof (received[0] as { seq?: unknown }).seq).toBe("number");
+  });
+
+  test("rejects a message that is not a known event type", async () => {
+    const received = subscribe();
+
+    await expect(
+      handleEventsPublish({
+        body: { event: fullEvent({ type: "not_a_real_event" }) },
+      }),
+    ).rejects.toThrow();
+    expect(received).toHaveLength(0);
   });
 
   test("rejects an incomplete envelope (missing id)", async () => {
@@ -60,7 +89,7 @@ describe(`${EVENTS_PUBLISH_IPC_METHOD} IPC route`, () => {
         body: {
           event: {
             emittedAt: "2026-07-21T00:00:00.000Z",
-            message: { type: "test_event" },
+            message: { type: "generation_cancelled" },
           },
         },
       }),

package/src/ipc/routes/events-ipc-routes.ts

@@ -23,47 +23,27 @@
 import { z } from "zod";
 
 import { AssistantEventEnvelopeSchema } from "../../api/index.js";
-import {
-  HOST_PROXY_CAPABILITIES,
-  INTERFACE_IDS,
-} from "../../channels/types.js";
-import type { ServerMessage } from "../../daemon/message-protocol.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
+import { AssistantEventPublishOptionsSchema } from "../../runtime/assistant-event-publish-options.js";
+import { stampAndBuffer } from "../../runtime/assistant-stream-state.js";
 import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
-
-/** IPC method name — the raw publish transport other processes call. */
-export const EVENTS_PUBLISH_IPC_METHOD = "/events/publish";
-
-/**
- * The event envelope reuses the shared wire schema's transport fields (`id`,
- * `emittedAt`, `conversationId`, `seq`) and overrides only `message`: the hub
- * publishes runtime `ServerMessage`-typed events, whose union is defined
- * separately from the api schema's message union, so the override yields a
- * value assignable to `assistantEventHub.publish` without a cast.
- */
-const EventEnvelopeSchema = AssistantEventEnvelopeSchema.extend({
-  message: z.custom<ServerMessage>(
-    (value) => value != null && typeof value === "object",
-  ),
-});
-
-/** Publish targeting/suppression options — see the hub's `publish`. */
-const PublishOptionsSchema = z.object({
-  targetCapability: z.enum(HOST_PROXY_CAPABILITIES).optional(),
-  targetClientId: z.string().optional(),
-  targetInterfaceId: z.enum(INTERFACE_IDS).optional(),
-  excludeClientId: z.string().optional(),
-});
+import { EVENTS_PUBLISH_IPC_METHOD } from "../events-publish-client.js";
 
 const EventsPublishParamsSchema = z.object({
-  event: EventEnvelopeSchema,
-  options: PublishOptionsSchema.optional(),
+  event: AssistantEventEnvelopeSchema,
+  options: AssistantEventPublishOptionsSchema.optional(),
 });
 
 export async function handleEventsPublish({
   body = {},
 }: RouteHandlerArgs): Promise<{ ok: true }> {
   const { event, options } = EventsPublishParamsSchema.parse(body);
+  // A forwarded event comes from a process where seq stamping is disabled
+  // (a worker), so it arrives with no `seq` and was never buffered for SSE
+  // replay. The daemon is the seq authority, so stamp + buffer here — at the
+  // transport boundary, before fanout — exactly as `broadcastMessage` does on
+  // the in-daemon path, so reconnecting clients replay it in order.
+  stampAndBuffer(event, { targeting: options });
   await assistantEventHub.publish(event, options);
   return { ok: true };
 }