@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/daemon/tool-side-effects.ts

@@ -9,13 +9,14 @@
 
 import { isAbsolute, resolve, sep } from "node:path";
 
-import { addAppConversationId, getApp } from "../apps/app-store.js";
+import type { AssistantEvent } from "../api/index.js";
+import { getApp, linkAppToConversationLineage } from "../apps/app-store.js";
 import { findActiveSession } from "../channels/gateway-verification-sessions.js";
 import { getConfig } from "../config/loader.js";
 import { generateAppIcon } from "../media/app-icon-generator.js";
-import { invalidateEdgeIndex } from "../plugins/defaults/memory/v3/substrate/edge-index.js";
-import { invalidatePageIndex } from "../plugins/defaults/memory/v3/substrate/page-index.js";
-import { getConceptsDir } from "../plugins/defaults/memory/v3/substrate/page-store.js";
+import { invalidateEdgeIndex } from "../plugins/defaults/memory/substrate/edge-index.js";
+import { invalidatePageIndex } from "../plugins/defaults/memory/substrate/page-index.js";
+import { getConceptsDir } from "../plugins/defaults/memory/substrate/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
 import { deliverVerificationSlack } from "../runtime/verification-outbound-actions.js";
@@ -26,7 +27,6 @@ import { getWorkspaceDir } from "../util/platform.js";
 import { ensureAppSourceWatcher } from "./app-source-watcher.js";
 import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { isDoordashCommand, updateDoordashProgress } from "./doordash-steps.js";
-import type { ServerMessage } from "./message-protocol.js";
 import type { ToolSetupContext } from "./tool-setup-types.js";
 
 const log = getLogger("tool-side-effects");
@@ -121,7 +121,7 @@ registerHook("app_create", (_name, _input, result, { ctx }) => {
     return;
   }
   try {
-    addAppConversationId(appId, ctx.conversationId);
+    linkAppToConversationLineage(appId, ctx.conversationId);
   } catch (err) {
     log.warn({ err, appId }, "Failed to track conversation ID on app_create");
   }
@@ -169,7 +169,7 @@ function registerAppSurfaceRefreshHook(toolName: string): void {
       return;
     }
     try {
-      addAppConversationId(appId, ctx.conversationId);
+      linkAppToConversationLineage(appId, ctx.conversationId);
     } catch (err) {
       log.warn({ err, appId }, `Failed to track conversation ID on ${name}`);
     }
@@ -181,7 +181,9 @@ registerAppSurfaceRefreshHook("app_update");
 
 registerHook("voice_config_update", (_name, input) => {
   const setting = input.setting as string | undefined;
-  if (!setting) return;
+  if (!setting) {
+    return;
+  }
 
   const SETTING_TO_KEY: Record<string, string> = {
     activation_key: "pttActivationKey",
@@ -191,7 +193,9 @@ registerHook("voice_config_update", (_name, input) => {
     fish_audio_reference_id: "fishAudioReferenceId",
   };
   const key = SETTING_TO_KEY[setting];
-  if (!key) return;
+  if (!key) {
+    return;
+  }
 
   // `ttsVoiceId` is an ElevenLabs concept on the desktop client. When the
   // active provider is managed (vellum) or anything else, the voice lives only
@@ -222,7 +226,7 @@ registerHook("voice_config_update", (_name, input) => {
     type: "client_settings_update",
     key,
     value: coerced,
-  } as unknown as ServerMessage);
+  } as unknown as AssistantEvent);
 });
 
 // Dispatch pending Slack DM delivery when a CLI verification command
@@ -231,8 +235,12 @@ registerHook("voice_config_update", (_name, input) => {
 // This hook runs in the unsandboxed daemon process and delivers the DM.
 registerHook("bash", async (_name, input, result) => {
   const command = (input.command ?? "") as string;
-  if (!command.includes("channel-verification-sessions")) return;
-  if (!result.content.includes("_pendingSlackDm")) return;
+  if (!command.includes("channel-verification-sessions")) {
+    return;
+  }
+  if (!result.content.includes("_pendingSlackDm")) {
+    return;
+  }
 
   type PendingDm = { userId: string; text: string; assistantId: string };
   type Parsed = { _pendingSlackDm?: PendingDm };
@@ -288,18 +296,24 @@ registerHook("bash", async (_name, input, result) => {
     // multi-object output (e.g. cancel + create chained with &&).
   }
   if (singleObject !== undefined) {
-    if ((await dispatch(singleObject)) !== null) return;
+    if ((await dispatch(singleObject)) !== null) {
+      return;
+    }
   }
   for (const line of result.content.split("\n")) {
     const trimmed = line.trim();
-    if (!trimmed.startsWith("{")) continue;
+    if (!trimmed.startsWith("{")) {
+      continue;
+    }
     let parsed: Parsed;
     try {
       parsed = JSON.parse(trimmed) as Parsed;
     } catch {
       continue;
     }
-    if ((await dispatch(parsed)) === "delivered") return;
+    if ((await dispatch(parsed)) === "delivered") {
+      return;
+    }
   }
 });
 
@@ -311,7 +325,9 @@ function invalidateEdgeIndexIfConceptPage(
   input: Record<string, unknown>,
 ): void {
   const rawPath = input.path;
-  if (typeof rawPath !== "string" || rawPath.length === 0) return;
+  if (typeof rawPath !== "string" || rawPath.length === 0) {
+    return;
+  }
   const workspaceDir = getWorkspaceDir();
   const conceptsRoot = getConceptsDir(workspaceDir);
   const absPath = isAbsolute(rawPath)

package/src/daemon/trust-context.ts

@@ -7,7 +7,7 @@
 import type { ChannelConversationType } from "@vellumai/gateway-client";
 
 import { isHttpAuthDisabled } from "../config/env.js";
-import { shouldExposePersonalMemory } from "../plugins/defaults/memory/v3/substrate/static-context.js";
+import { shouldExposePersonalMemory } from "../plugins/defaults/memory/substrate/static-context.js";
 import type { TrustClass } from "../runtime/trust-class.js";
 import type { TrustContext } from "./trust-context-types.js";
 

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

@@ -13,6 +13,7 @@
  */
 
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
 import {
   addMessage,
   getConversation,
@@ -27,7 +28,6 @@ import { publishConversationMessagesChanged } from "../runtime/sync/resource-syn
 import type { CompletedBackgroundTool } from "../tools/background-tool-registry.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
-import type { ServerMessage } from "./message-protocol.js";
 import type {
   SubagentToolGateMode,
   WakeToolContextPin,
@@ -37,7 +37,7 @@ const log = getLogger("wake-conversation-ops");
 
 /**
  * Translate a raw {@link AgentEvent} from the agent loop into the
- * corresponding {@link ServerMessage} wire frame. The normal user-turn
+ * corresponding {@link AssistantEvent} wire frame. The normal user-turn
  * path does this via the full state-aware handler in
  * `conversation-agent-loop-handlers.ts`; the wake path has no tool
  * accounting, title generation, or activity-state tracking to worry
@@ -48,7 +48,7 @@ const log = getLogger("wake-conversation-ops");
 function translateAgentEventToServerMessage(
   event: AgentEvent,
   conversationId: string,
-): ServerMessage | null {
+): AssistantEvent | null {
   switch (event.type) {
     case "text_delta":
       return {
@@ -176,7 +176,7 @@ export function emitWakeAgentEvent(
     event,
     conversation.conversationId,
   );
-  if (!frame) return;
+  if (!frame) {return;}
   broadcastMessage(frame);
 }
 

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

@@ -4,9 +4,11 @@ import { sql } from "drizzle-orm";
 
 import { getDb } from "../../persistence/db-connection.js";
 import { initializeDb } from "../../persistence/db-init.js";
+import { heartbeatRuns } from "../../persistence/schema/index.js";
 import {
   completeHeartbeatRun,
   countCompletedHeartbeatRuns,
+  getLastHeartbeatRunAt,
   insertPendingHeartbeatRun,
   listHeartbeatRuns,
   markStaleRunningAsError,
@@ -18,6 +20,19 @@ import {
 
 await initializeDb();
 
+/**
+ * Raw read-back of every row (any status). `listHeartbeatRuns` serves run
+ * history and hides bookkeeping rows (pending/superseded), so tests that
+ * assert on those statuses read the table directly.
+ */
+function allRuns() {
+  return getDb()
+    .select()
+    .from(heartbeatRuns)
+    .orderBy(sql`${heartbeatRuns.scheduledFor} DESC`)
+    .all();
+}
+
 describe("heartbeat-run-store", () => {
   beforeEach(() => {
     const db = getDb();
@@ -29,7 +44,7 @@ describe("heartbeat-run-store", () => {
     const id = insertPendingHeartbeatRun(scheduledFor);
     expect(id).toBeTruthy();
 
-    const rows = listHeartbeatRuns();
+    const rows = allRuns();
     expect(rows).toHaveLength(1);
     expect(rows[0].id).toBe(id);
     expect(rows[0].status).toBe("pending");
@@ -134,7 +149,7 @@ describe("heartbeat-run-store", () => {
     const ok = supersedePendingRun(id);
     expect(ok).toBe(true);
 
-    const rows = listHeartbeatRuns();
+    const rows = allRuns();
     expect(rows[0].status).toBe("superseded");
   });
 
@@ -156,7 +171,7 @@ describe("heartbeat-run-store", () => {
     const count = markStaleRunsAsMissed(5 * 60 * 1000);
     expect(count).toBe(2);
 
-    const rows = listHeartbeatRuns();
+    const rows = allRuns();
     const byId = Object.fromEntries(rows.map((r) => [r.id, r]));
     expect(byId[id1].status).toBe("missed");
     expect(byId[id2].status).toBe("missed");
@@ -185,9 +200,9 @@ describe("heartbeat-run-store", () => {
 
   test("listHeartbeatRuns returns rows ordered by scheduledFor desc", () => {
     const now = Date.now();
-    insertPendingHeartbeatRun(now - 2000);
-    insertPendingHeartbeatRun(now);
-    insertPendingHeartbeatRun(now - 1000);
+    skipHeartbeatRun(insertPendingHeartbeatRun(now - 2000), "overlap");
+    skipHeartbeatRun(insertPendingHeartbeatRun(now), "overlap");
+    skipHeartbeatRun(insertPendingHeartbeatRun(now - 1000), "overlap");
 
     const rows = listHeartbeatRuns();
     expect(rows).toHaveLength(3);
@@ -199,13 +214,48 @@ describe("heartbeat-run-store", () => {
   test("listHeartbeatRuns respects limit", () => {
     const now = Date.now();
     for (let i = 0; i < 5; i++) {
-      insertPendingHeartbeatRun(now + i);
+      skipHeartbeatRun(insertPendingHeartbeatRun(now + i), "overlap");
     }
 
     const rows = listHeartbeatRuns(3);
     expect(rows).toHaveLength(3);
   });
 
+  test("listHeartbeatRuns hides bookkeeping rows (pending, superseded)", () => {
+    const now = Date.now();
+
+    // Superseded rows: pending runs replaced by timer resets, scheduled in
+    // the future at insert time — never ran.
+    for (let i = 0; i < 3; i++) {
+      supersedePendingRun(insertPendingHeartbeatRun(now + 60 * 60 * 1000 + i));
+    }
+    // The not-yet-fired next scheduled run.
+    insertPendingHeartbeatRun(now + 60 * 60 * 1000 + 10);
+
+    // Real history: a completed run, a skipped run, a missed run, and one
+    // in flight.
+    const okId = insertPendingHeartbeatRun(now - 3000);
+    startHeartbeatRun(okId);
+    completeHeartbeatRun(okId, { status: "ok", conversationId: "conv-1" });
+    const skippedId = insertPendingHeartbeatRun(now - 2000);
+    skipHeartbeatRun(skippedId, "outside_active_hours");
+    const missedId = insertPendingHeartbeatRun(now - 10 * 60 * 1000);
+    markStaleRunsAsMissed(5 * 60 * 1000);
+    const runningId = insertPendingHeartbeatRun(now - 1000);
+    startHeartbeatRun(runningId);
+
+    const rows = listHeartbeatRuns();
+    expect(rows.map((r) => r.id).sort()).toEqual(
+      [okId, skippedId, missedId, runningId].sort(),
+    );
+
+    // The pagination cursor path applies the same filter.
+    const paged = listHeartbeatRuns(10, now + 2 * 60 * 60 * 1000);
+    expect(paged.map((r) => r.id).sort()).toEqual(
+      [okId, skippedId, missedId, runningId].sort(),
+    );
+  });
+
   test("countCompletedHeartbeatRuns counts only ok rows", () => {
     const now = Date.now();
 
@@ -240,4 +290,47 @@ describe("heartbeat-run-store", () => {
 
     expect(countCompletedHeartbeatRuns()).toBe(0);
   });
+
+  test("getLastHeartbeatRunAt returns the newest executed-run timestamp", () => {
+    const now = Date.now();
+
+    const oldId = insertPendingHeartbeatRun(now - 5000);
+    startHeartbeatRun(oldId);
+    completeHeartbeatRun(oldId, { status: "ok", conversationId: "conv-1" });
+
+    const newId = insertPendingHeartbeatRun(now - 1000);
+    startHeartbeatRun(newId);
+    completeHeartbeatRun(newId, { status: "error", error: "fail" });
+
+    // Non-executed rows never contribute, even when newer.
+    skipHeartbeatRun(insertPendingHeartbeatRun(now), "outside_active_hours");
+    insertPendingHeartbeatRun(now + 60 * 60 * 1000);
+
+    const newRow = allRuns().find((r) => r.id === newId);
+    expect(getLastHeartbeatRunAt()).toBe(newRow!.finishedAt!);
+  });
+
+  test("getLastHeartbeatRunAt falls back to startedAt when finishedAt is null", () => {
+    const now = Date.now();
+    const id = insertPendingHeartbeatRun(now - 60 * 60 * 1000);
+    startHeartbeatRun(id);
+    const db = getDb();
+    const backdatedStartedAt = now - 60 * 60 * 1000;
+    db.run(
+      sql`UPDATE heartbeat_runs SET started_at = ${backdatedStartedAt} WHERE id = ${id}`,
+    );
+    // Crash sweep finalizes the row as error without a finishedAt.
+    markStaleRunningAsError(45 * 60 * 1000);
+
+    expect(getLastHeartbeatRunAt()).toBe(backdatedStartedAt);
+  });
+
+  test("getLastHeartbeatRunAt returns null when no run ever executed", () => {
+    expect(getLastHeartbeatRunAt()).toBeNull();
+
+    skipHeartbeatRun(insertPendingHeartbeatRun(Date.now()), "disabled");
+    supersedePendingRun(insertPendingHeartbeatRun(Date.now() + 1));
+
+    expect(getLastHeartbeatRunAt()).toBeNull();
+  });
 });

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -178,6 +178,7 @@ mock.module("../../credential-health/credential-health-service.js", () => ({
 // Stub the heartbeat-run-store so the tests don't need a populated SQLite
 // schema. Each function is a no-op that returns sensible defaults.
 let heartbeatRunIdCounter = 0;
+let lastRunAtFromHistory: number | null = null;
 const skipHeartbeatRunCalls: Array<{ runId: string; reason: string }> = [];
 mock.module("../heartbeat-run-store.js", () => ({
   insertPendingHeartbeatRun: () => `heartbeat-run-${++heartbeatRunIdCounter}`,
@@ -192,6 +193,7 @@ mock.module("../heartbeat-run-store.js", () => ({
   countCompletedHeartbeatRuns: () => 10,
   countCompletedRunsToday: () => 0,
   countRecentConsecutiveRuns: () => 0,
+  getLastHeartbeatRunAt: () => lastRunAtFromHistory,
 }));
 
 // Stub the pre-first-message gate so tests can flip it on/off without
@@ -202,6 +204,16 @@ mock.module("../../runtime/pre-first-message-gate.js", () => ({
   hasReceivedUserMessage: () => preFirstMessageGateOpen,
 }));
 
+// Stub the drain quiesce lease so tests can flip it without a database.
+// Defaults to INACTIVE so existing tests keep passing.
+const realLifecycleQuiesce =
+  await import("../../persistence/lifecycle-quiesce.js");
+let quiesceLeaseActive = false;
+mock.module("../../persistence/lifecycle-quiesce.js", () => ({
+  ...realLifecycleQuiesce,
+  isLifecycleQuiesced: () => quiesceLeaseActive,
+}));
+
 const { HeartbeatService } = await import("../heartbeat-service.js");
 
 let origWorkspaceDir: string | undefined;
@@ -215,6 +227,7 @@ beforeEach(() => {
   onBroadcast = null;
   runBackgroundJobCalls.length = 0;
   skipHeartbeatRunCalls.length = 0;
+  lastRunAtFromHistory = null;
   preFirstMessageGateOpen = true;
   seedHeartbeat();
   runBackgroundJobImpl = async () => ({
@@ -260,6 +273,24 @@ describe("HeartbeatService", () => {
     expect(call.prompt).toContain("<heartbeat-disposition>");
   });
 
+  test("lastRunAt rehydrates from run history when unset in memory", async () => {
+    const historicalRunAt = Date.now() - 60 * 60 * 1000;
+    lastRunAtFromHistory = historicalRunAt;
+
+    const service = new HeartbeatService();
+    expect(service.lastRunAt).toBe(historicalRunAt);
+
+    // An in-process run takes over from the rehydrated value.
+    await service.runOnce({ force: true });
+    expect(service.lastRunAt).toBeGreaterThan(historicalRunAt);
+  });
+
+  test("lastRunAt is null when no run has ever executed", () => {
+    lastRunAtFromHistory = null;
+    const service = new HeartbeatService();
+    expect(service.lastRunAt).toBeNull();
+  });
+
   test("fires onConversationCreated synchronously via the runner BEFORE the runner returns", async () => {
     const created: Array<{ conversationId: string; title: string }> = [];
     let runnerHasResolved = false;
@@ -389,6 +420,42 @@ describe("HeartbeatService", () => {
     ).toBe(false);
   });
 
+  test("scheduled run skips with reason 'quiesced' while the drain lease is active", async () => {
+    quiesceLeaseActive = true;
+    const service = new HeartbeatService();
+    service.start();
+    skipHeartbeatRunCalls.length = 0;
+
+    try {
+      const result = await service.runOnce({ force: false });
+
+      expect(result).toBe(false);
+      expect(runBackgroundJobCalls).toHaveLength(0);
+      expect(skipHeartbeatRunCalls.some((c) => c.reason === "quiesced")).toBe(
+        true,
+      );
+    } finally {
+      await service.stop();
+      quiesceLeaseActive = false;
+    }
+  });
+
+  test("forced run bypasses the quiesce gate (manual operator action)", async () => {
+    quiesceLeaseActive = true;
+    const service = new HeartbeatService();
+
+    try {
+      await service.runOnce({ force: true });
+
+      expect(runBackgroundJobCalls).toHaveLength(1);
+      expect(skipHeartbeatRunCalls.some((c) => c.reason === "quiesced")).toBe(
+        false,
+      );
+    } finally {
+      quiesceLeaseActive = false;
+    }
+  });
+
   describe("max consecutive runs cap", () => {
     test("skips with reason 'max_consecutive_runs' after the cap is hit", async () => {
       seedHeartbeat({ maxConsecutiveRuns: 2 });

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", () => ({