@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -0,0 +1,183 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    heartbeat: {
+      enabled: true,
+      intervalMs: 60_000,
+      cronExpression: null,
+      timezone: null,
+      activeHoursStart: undefined,
+      activeHoursEnd: undefined,
+    },
+  }),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getConfigReadOnly: () => ({}),
+  applyNestedDefaults: (config: unknown) => config,
+  deepMergeOverwrite: (base: unknown) => base,
+  mergeDefaultWorkspaceConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  API_KEY_PROVIDERS: [],
+  _appendQuarantineBulletin: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+const mockInsertPendingHeartbeatRun = mock(() => "run-1");
+const mockStartHeartbeatRun = mock(() => true);
+const mockCompleteHeartbeatRun = mock(() => true);
+const mockSkipHeartbeatRun = mock(() => true);
+const mockMarkStaleRunsAsMissed = mock(() => 0);
+const mockMarkStaleRunningAsError = mock(() => 0);
+mock.module("../heartbeat/heartbeat-run-store.js", () => ({
+  insertPendingHeartbeatRun: mockInsertPendingHeartbeatRun,
+  startHeartbeatRun: mockStartHeartbeatRun,
+  completeHeartbeatRun: mockCompleteHeartbeatRun,
+  skipHeartbeatRun: mockSkipHeartbeatRun,
+  supersedePendingRun: mock(() => true),
+  markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
+  markStaleRunningAsError: mockMarkStaleRunningAsError,
+  countCompletedHeartbeatRuns: mock(() => 10),
+}));
+
+mock.module("../schedule/recurrence-engine.js", () => ({
+  computeNextRunAt: () => Date.now() + 60_000,
+}));
+
+const createdConversations: Array<{ conversationType: string }> = [];
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversation: () => null,
+  getMessages: () => [],
+  createConversation: (opts: { conversationType: string }) => {
+    createdConversations.push(opts);
+    return { id: "conv-1", ...opts };
+  },
+}));
+
+const mockProcessMessage = mock(() => Promise.resolve({ messageId: "msg-1" }));
+mock.module("../daemon/process-message.js", () => ({
+  processMessage: mockProcessMessage,
+}));
+
+const mockEmitFeedEvent = mock(() => Promise.resolve());
+mock.module("../home/emit-feed-event.js", () => ({
+  emitFeedEvent: mockEmitFeedEvent,
+}));
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  GUARDIAN_PERSONA_TEMPLATE: "# User Profile\n",
+  resolveGuardianPersona: () => "# User Profile\n",
+}));
+
+mock.module("../memory/conversation-title-service.js", () => ({
+  GENERATING_TITLE: "Generating title...",
+  queueGenerateConversationTitle: () => {},
+}));
+
+mock.module("../daemon/disk-pressure-background-gate.js", () => ({
+  checkDiskPressureBackgroundGate: () => ({
+    action: "skip",
+    reason: "disk_pressure",
+    blockedCapability: "background-work",
+    status: {
+      enabled: true,
+      state: "critical",
+      locked: true,
+      acknowledged: true,
+      overrideActive: false,
+      effectivelyLocked: true,
+      lockId: "disk-pressure-test",
+      usagePercent: 98,
+      thresholdPercent: 95,
+      path: "/",
+      lastCheckedAt: "2026-05-05T00:00:00.000Z",
+      blockedCapabilities: ["agent-turns", "background-work", "remote-ingress"],
+      error: null,
+    },
+  }),
+  diskPressureBackgroundSkipLogFields: () => ({
+    reason: "disk_pressure",
+    thresholdPercent: 95,
+    usagePercent: 98,
+    blockedCapability: "background-work",
+    lockId: "disk-pressure-test",
+    path: "/",
+  }),
+  shouldLogDiskPressureBackgroundSkip: () => true,
+}));
+
+const { HeartbeatService } = await import("../heartbeat/heartbeat-service.js");
+
+describe("HeartbeatService disk pressure gate", () => {
+  beforeEach(() => {
+    createdConversations.length = 0;
+    mockInsertPendingHeartbeatRun.mockClear();
+    mockStartHeartbeatRun.mockClear();
+    mockCompleteHeartbeatRun.mockClear();
+    mockSkipHeartbeatRun.mockClear();
+    mockMarkStaleRunsAsMissed.mockClear();
+    mockMarkStaleRunsAsMissed.mockImplementation(() => 0);
+    mockMarkStaleRunningAsError.mockClear();
+    mockMarkStaleRunningAsError.mockImplementation(() => 0);
+    mockProcessMessage.mockClear();
+    mockEmitFeedEvent.mockClear();
+  });
+
+  test("skips without creating heartbeat rows, conversations, or feed events", async () => {
+    const service = new HeartbeatService({
+      alerter: () => {},
+    });
+
+    const ran = await service.runOnce();
+
+    expect(ran).toBe(false);
+    expect(mockInsertPendingHeartbeatRun).not.toHaveBeenCalled();
+    expect(mockStartHeartbeatRun).not.toHaveBeenCalled();
+    expect(mockCompleteHeartbeatRun).not.toHaveBeenCalled();
+    expect(mockSkipHeartbeatRun).not.toHaveBeenCalled();
+    expect(createdConversations).toHaveLength(0);
+    expect(mockProcessMessage).not.toHaveBeenCalled();
+    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
+  });
+
+  test("allows forced user-initiated heartbeat runs while locked", async () => {
+    const service = new HeartbeatService({
+      alerter: () => {},
+    });
+
+    const ran = await service.runOnce({ force: true });
+
+    expect(ran).toBe(true);
+    expect(mockStartHeartbeatRun).toHaveBeenCalled();
+    expect(mockCompleteHeartbeatRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ status: "ok" }),
+    );
+    expect(createdConversations).toHaveLength(1);
+    expect(mockProcessMessage).toHaveBeenCalledTimes(1);
+  });
+
+  test("start recovery skips missed-run feed events while locked", async () => {
+    mockMarkStaleRunsAsMissed.mockImplementationOnce(() => 1);
+    const service = new HeartbeatService({
+      alerter: () => {},
+    });
+
+    service.start();
+    await service.stop();
+
+    expect(mockMarkStaleRunsAsMissed).toHaveBeenCalledTimes(1);
+    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
+  });
+});

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

@@ -20,6 +20,8 @@ const mockSkipHeartbeatRun = mock(() => true);
 const mockSupersedePendingRun = mock(() => true);
 const mockMarkStaleRunsAsMissed = mock(() => 0);
 const mockMarkStaleRunningAsError = mock(() => 0);
+const mockListHeartbeatRuns = mock(() => []);
+const mockCountCompletedHeartbeatRuns = mock(() => 10);
 mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   insertPendingHeartbeatRun: mockInsertPendingHeartbeatRun,
   startHeartbeatRun: mockStartHeartbeatRun,
@@ -28,6 +30,8 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   supersedePendingRun: mockSupersedePendingRun,
   markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
   markStaleRunningAsError: mockMarkStaleRunningAsError,
+  listHeartbeatRuns: mockListHeartbeatRuns,
+  countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
 }));
 
 // ── Feed event mock ───────────────────────────────────────────────
@@ -119,6 +123,14 @@ mock.module("../prompts/persona-resolver.js", () => ({
 const createdConversations: Array<{ title: string; conversationType: string }> =
   [];
 let conversationIdCounter = 0;
+const mockStoredMessages: Array<{
+  id: string;
+  conversationId: string;
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata: string | null;
+}> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
@@ -127,7 +139,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   updateConversationUsage: () => {},
   addMessage: () => ({ id: "mock-msg-id" }),
-  getMessages: () => [],
+  getMessages: () => mockStoredMessages,
   getConversation: () => ({
     id: "conv-1",
     contextSummary: null,
@@ -199,21 +211,36 @@ mock.module("../credential-health/credential-health-service.js", () => ({
 // `notifyUnhealthyCredentials` dynamically imports `emitNotificationSignal`.
 // Track calls so tests can assert which credentials were notified about.
 const emittedNotificationSignals: Array<{
+  sourceEventName?: string;
+  sourceChannel?: string;
   sourceContextId: string;
   dedupeKey: string;
+  attentionHints?: Record<string, unknown>;
   contextPayload: Record<string, unknown>;
+  conversationAffinityHint?: Record<string, string>;
+  conversationMetadata?: Record<string, unknown>;
 }> = [];
 
 mock.module("../notifications/emit-signal.js", () => ({
   emitNotificationSignal: async (opts: {
+    sourceEventName?: string;
+    sourceChannel?: string;
     sourceContextId: string;
     dedupeKey: string;
+    attentionHints?: Record<string, unknown>;
     contextPayload: Record<string, unknown>;
+    conversationAffinityHint?: Record<string, string>;
+    conversationMetadata?: Record<string, unknown>;
   }) => {
     emittedNotificationSignals.push({
+      sourceEventName: opts.sourceEventName,
+      sourceChannel: opts.sourceChannel,
       sourceContextId: opts.sourceContextId,
       dedupeKey: opts.dedupeKey,
+      attentionHints: opts.attentionHints,
       contextPayload: opts.contextPayload,
+      conversationAffinityHint: opts.conversationAffinityHint,
+      conversationMetadata: opts.conversationMetadata,
     });
   },
 }));
@@ -318,6 +345,7 @@ describe("HeartbeatService", () => {
     alerterCalls = [];
     createdConversations.length = 0;
     conversationIdCounter = 0;
+    mockStoredMessages.length = 0;
     mockGuardianPersona = null;
     mockCredentialHealthReport = null;
     mockCheckAllCredentialsFail = false;
@@ -351,6 +379,10 @@ describe("HeartbeatService", () => {
     mockMarkStaleRunsAsMissed.mockImplementation(() => 0);
     mockMarkStaleRunningAsError.mockClear();
     mockMarkStaleRunningAsError.mockImplementation(() => 0);
+    mockListHeartbeatRuns.mockClear();
+    mockListHeartbeatRuns.mockImplementation(() => []);
+    mockCountCompletedHeartbeatRuns.mockClear();
+    mockCountCompletedHeartbeatRuns.mockImplementation(() => 10);
     mockEmitFeedEvent.mockClear();
     mockEmitFeedEvent.mockImplementation(() => Promise.resolve());
 
@@ -369,6 +401,10 @@ describe("HeartbeatService", () => {
   function createService(overrides?: {
     processMessage?: (...args: unknown[]) => Promise<{ messageId: string }>;
     getCurrentHour?: () => number;
+    onConversationCreated?: (info: {
+      conversationId: string;
+      title: string;
+    }) => void;
   }) {
     if (overrides?.processMessage) {
       setTestProcessMessage(overrides.processMessage);
@@ -377,6 +413,7 @@ describe("HeartbeatService", () => {
       alerter: (alert: { type: string; title: string; body: string }) => {
         alerterCalls.push(alert);
       },
+      onConversationCreated: overrides?.onConversationCreated,
       getCurrentHour: overrides?.getCurrentHour,
     });
   }
@@ -721,6 +758,149 @@ describe("HeartbeatService", () => {
     });
   });
 
+  test("HEARTBEAT_ALERT emits a notification signal and surfaces the conversation", async () => {
+    const conversationCreatedCalls: Array<{
+      conversationId: string;
+      title: string;
+    }> = [];
+    const service = createService({
+      onConversationCreated: (info) => conversationCreatedCalls.push(info),
+      processMessage: async (...args: unknown[]) => {
+        const conversationId = args[0] as string;
+        mockStoredMessages.push({
+          id: "assistant-alert-1",
+          conversationId,
+          role: "assistant",
+          content: JSON.stringify([
+            {
+              type: "text",
+              text: "The first heartbeat found a concrete follow-up for the guardian.\nHEARTBEAT_ALERT",
+            },
+          ]),
+          createdAt: Date.now(),
+          metadata: null,
+        });
+        return { messageId: "user-heartbeat-1" };
+      },
+    });
+
+    await service.runOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(conversationCreatedCalls).toEqual([
+      { conversationId: "conv-1", title: "Heartbeat" },
+    ]);
+    expect(emittedNotificationSignals).toHaveLength(1);
+    expect(emittedNotificationSignals[0]).toMatchObject({
+      sourceEventName: "heartbeat.alert",
+      sourceChannel: "watcher",
+      sourceContextId: "mock-run-id",
+      dedupeKey: "heartbeat:alert:mock-run-id",
+      attentionHints: {
+        requiresAction: true,
+        urgency: "medium",
+        isAsyncBackground: true,
+        visibleInSourceNow: false,
+      },
+      conversationAffinityHint: { vellum: "conv-1" },
+      conversationMetadata: {
+        source: "heartbeat",
+        groupId: "system:background",
+      },
+    });
+    expect(emittedNotificationSignals[0].contextPayload.summary).toBe(
+      "The first heartbeat found a concrete follow-up for the guardian.",
+    );
+    expect(emittedNotificationSignals[0].contextPayload.messageId).toBe(
+      "assistant-alert-1",
+    );
+    expect(
+      emittedNotificationSignals[0].contextPayload.sourceInterface,
+    ).toBeUndefined();
+  });
+
+  test("HEARTBEAT_OK stays silent", async () => {
+    const conversationCreatedCalls: Array<{
+      conversationId: string;
+      title: string;
+    }> = [];
+    const service = createService({
+      onConversationCreated: (info) => conversationCreatedCalls.push(info),
+      processMessage: async (...args: unknown[]) => {
+        const conversationId = args[0] as string;
+        mockStoredMessages.push({
+          id: "assistant-ok-1",
+          conversationId,
+          role: "assistant",
+          content: JSON.stringify([
+            {
+              type: "text",
+              text: "Everything looks good.\nHEARTBEAT_OK",
+            },
+          ]),
+          createdAt: Date.now(),
+          metadata: null,
+        });
+        return { messageId: "user-heartbeat-1" };
+      },
+    });
+
+    await service.runOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(conversationCreatedCalls).toHaveLength(0);
+    expect(emittedNotificationSignals).toHaveLength(0);
+    const successFeedCalls = mockEmitFeedEvent.mock.calls.filter(
+      (call: unknown[]) => {
+        const opts = call[0] as { dedupKey?: string };
+        return opts.dedupKey?.startsWith("heartbeat:ok:");
+      },
+    );
+    expect(successFeedCalls).toHaveLength(0);
+  });
+
+  test("HEARTBEAT_OK stays silent when earlier content mentions HEARTBEAT_ALERT", async () => {
+    const conversationCreatedCalls: Array<{
+      conversationId: string;
+      title: string;
+    }> = [];
+    const service = createService({
+      onConversationCreated: (info) => conversationCreatedCalls.push(info),
+      processMessage: async (...args: unknown[]) => {
+        const conversationId = args[0] as string;
+        mockStoredMessages.push({
+          id: "assistant-ok-2",
+          conversationId,
+          role: "assistant",
+          content: JSON.stringify([
+            {
+              type: "thinking",
+              thinking:
+                "I should decide between HEARTBEAT_ALERT and HEARTBEAT_OK.",
+            },
+            {
+              type: "tool_result",
+              content: "Tool output mentions HEARTBEAT_ALERT.",
+            },
+            {
+              type: "text",
+              text: "I considered HEARTBEAT_ALERT, but there is nothing useful to surface.\nHEARTBEAT_OK",
+            },
+          ]),
+          createdAt: Date.now(),
+          metadata: null,
+        });
+        return { messageId: "user-heartbeat-1" };
+      },
+    });
+
+    await service.runOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(conversationCreatedCalls).toHaveLength(0);
+    expect(emittedNotificationSignals).toHaveLength(0);
+  });
+
   test("end-to-end: llm.callSites.heartbeatAgent.speed resolves to 'fast'", async () => {
     // Verifies the contract that PR 7 establishes: heartbeat passes
     // `callSite: 'heartbeatAgent'`, and the LLM resolver maps that to the
@@ -1354,20 +1534,38 @@ describe("HeartbeatService", () => {
       });
     });
 
-    test("CAS false suppresses success feed event", async () => {
+    test("CAS false suppresses success surfacing", async () => {
       mockCompleteHeartbeatRun.mockImplementation(() => false);
 
-      const service = createService();
+      const conversationCreatedCalls: Array<{
+        conversationId: string;
+        title: string;
+      }> = [];
+      const service = createService({
+        onConversationCreated: (info) => conversationCreatedCalls.push(info),
+        processMessage: async (...args: unknown[]) => {
+          const conversationId = args[0] as string;
+          mockStoredMessages.push({
+            id: "assistant-alert-1",
+            conversationId,
+            role: "assistant",
+            content: JSON.stringify([
+              {
+                type: "text",
+                text: "Something worth surfacing.\nHEARTBEAT_ALERT",
+              },
+            ]),
+            createdAt: Date.now(),
+            metadata: null,
+          });
+          return { messageId: "msg-1" };
+        },
+      });
       await service.runOnce();
+      await new Promise((resolve) => setTimeout(resolve, 0));
 
-      // completeHeartbeatRun returned false, so no feed event should be emitted for success
-      const successCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { dedupKey?: string };
-          return opts.dedupKey?.startsWith("heartbeat:ok:");
-        },
-      );
-      expect(successCalls).toHaveLength(0);
+      expect(conversationCreatedCalls).toHaveLength(0);
+      expect(emittedNotificationSignals).toHaveLength(0);
     });
 
     test("CAS false suppresses failure alerter and feed event", async () => {
@@ -1770,4 +1968,55 @@ describe("HeartbeatService", () => {
       service.stop();
     });
   });
+
+  describe("early heartbeat nudge", () => {
+    test("includes <early-heartbeat> when completedRunCount is 0", () => {
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 0);
+
+      expect(prompt).toContain("<early-heartbeat>");
+      expect(prompt).toContain("first heartbeats");
+    });
+
+    test("includes <early-heartbeat> when completedRunCount is 2", () => {
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 2);
+
+      expect(prompt).toContain("<early-heartbeat>");
+    });
+
+    test("omits <early-heartbeat> when completedRunCount is 3", () => {
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 3);
+
+      expect(prompt).not.toContain("<early-heartbeat>");
+    });
+
+    test("omits <early-heartbeat> when completedRunCount is 10", () => {
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 10);
+
+      expect(prompt).not.toContain("<early-heartbeat>");
+    });
+
+    test("executeRun passes completed run count to buildPrompt", async () => {
+      mockCountCompletedHeartbeatRuns.mockImplementation(() => 0);
+
+      const service = createService();
+      await service.runOnce();
+
+      expect(processMessageCalls).toHaveLength(1);
+      expect(processMessageCalls[0].content).toContain("<early-heartbeat>");
+    });
+
+    test("executeRun omits nudge when enough runs have completed", async () => {
+      mockCountCompletedHeartbeatRuns.mockImplementation(() => 5);
+
+      const service = createService();
+      await service.runOnce();
+
+      expect(processMessageCalls).toHaveLength(1);
+      expect(processMessageCalls[0].content).not.toContain("<early-heartbeat>");
+    });
+  });
 });