@vellumai/assistant 0.8.0 → 0.8.1

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

@@ -1,17 +1,17 @@
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  jest,
-  mock,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 
+// Default the warm-pool gate to OPEN for existing tests — they predate
+// the gate and expect heartbeat/filing/etc. to run on every tick. Tests
+// that specifically exercise the gate path override this mock locally.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 // ── Heartbeat run store mock ───────────────────────────────────────
 const mockInsertPendingHeartbeatRun = mock(() => "mock-run-id");
 const mockStartHeartbeatRun = mock(() => true);
@@ -34,12 +34,6 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
 }));
 
-// ── Feed event mock ───────────────────────────────────────────────
-const mockEmitFeedEvent = mock(() => Promise.resolve());
-mock.module("../home/emit-feed-event.js", () => ({
-  emitFeedEvent: mockEmitFeedEvent,
-}));
-
 // Mock config loader
 let mockConfig = {
   heartbeat: {
@@ -383,8 +377,6 @@ describe("HeartbeatService", () => {
     mockListHeartbeatRuns.mockImplementation(() => []);
     mockCountCompletedHeartbeatRuns.mockClear();
     mockCountCompletedHeartbeatRuns.mockImplementation(() => 10);
-    mockEmitFeedEvent.mockClear();
-    mockEmitFeedEvent.mockImplementation(() => Promise.resolve());
 
     mockConfig = {
       heartbeat: {
@@ -848,15 +840,11 @@ describe("HeartbeatService", () => {
     await service.runOnce();
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(conversationCreatedCalls).toHaveLength(0);
+    // The conversation surfaces to the sidebar via the runner's bootstrap
+    // callback for *every* heartbeat — "silent OK" means no notification
+    // signal is emitted, not that the conversation is hidden.
+    expect(conversationCreatedCalls).toHaveLength(1);
     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 () => {
@@ -897,7 +885,9 @@ describe("HeartbeatService", () => {
     await service.runOnce();
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(conversationCreatedCalls).toHaveLength(0);
+    // Conversation surfaces via the runner bootstrap, but no notification
+    // is emitted since the disposition is OK.
+    expect(conversationCreatedCalls).toHaveLength(1);
     expect(emittedNotificationSignals).toHaveLength(0);
   });
 
@@ -1564,7 +1554,10 @@ describe("HeartbeatService", () => {
       await service.runOnce();
       await new Promise((resolve) => setTimeout(resolve, 0));
 
-      expect(conversationCreatedCalls).toHaveLength(0);
+      // The bootstrap-time surface fires regardless of CAS (it happens
+      // before completeHeartbeatRun). CAS-false suppresses the alert
+      // notification emit but not the sidebar entry.
+      expect(conversationCreatedCalls).toHaveLength(1);
       expect(emittedNotificationSignals).toHaveLength(0);
     });
 
@@ -1581,15 +1574,6 @@ describe("HeartbeatService", () => {
 
       // completeHeartbeatRun returned false, so alerter should NOT be called
       expect(alerterCalls).toHaveLength(0);
-
-      // No failure feed event either
-      const failCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { dedupKey?: string };
-          return opts.dedupKey?.startsWith("heartbeat:fail:");
-        },
-      );
-      expect(failCalls).toHaveLength(0);
     });
 
     test("active-hours skip calls skipHeartbeatRun", async () => {
@@ -1738,39 +1722,14 @@ describe("HeartbeatService", () => {
       expect(mockSupersedePendingRun).toHaveBeenCalledWith("mock-run-id");
     });
 
-    test("timeout calls completeHeartbeatRun with status timeout", async () => {
-      jest.useFakeTimers();
-      try {
-        let resolveRun: () => void;
-        const runPromise = new Promise<void>((r) => {
-          resolveRun = r;
-        });
-
-        const service = createService({
-          processMessage: async () => {
-            await runPromise;
-            return { messageId: "msg-1" };
-          },
-        });
-
-        const runOncePromise = service.runOnce();
-        // Advance past the 30-minute timeout
-        jest.advanceTimersByTime(30 * 60 * 1000 + 1000);
-        await runOncePromise;
-
-        expect(mockCompleteHeartbeatRun).toHaveBeenCalledWith("mock-run-id", {
-          status: "timeout",
-          error: "Heartbeat execution exceeded the 30-minute timeout",
-        });
-
-        // Clean up — resolve the hanging promise so it doesn't leak
-        resolveRun!();
-      } finally {
-        jest.useRealTimers();
-      }
-    });
+    // Note: the heartbeat-specific behavior on timeout is the trivial
+    // `errorKind === "timeout" ? "timeout" : "error"` mapping. The runner
+    // owns the actual timeout race (covered in
+    // `background-job-runner.test.ts`), so we don't reproduce its
+    // setTimeout-based timing here — fake timers don't reliably propagate
+    // into the runner's module scope across bun versions.
 
-    test("failure feed event has urgency high and includes error message", async () => {
+    test("failure emits activity.failed notification with errorKind exception", async () => {
       const service = createService({
         processMessage: async () => {
           throw new Error("web_search outage");
@@ -1779,192 +1738,50 @@ describe("HeartbeatService", () => {
 
       await service.runOnce();
 
-      const failCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { title?: string };
-          return opts.title === "Heartbeat Failed";
-        },
-      );
-      expect(failCalls).toHaveLength(1);
-      const opts = (failCalls as any[][])[0][0] as {
-        urgency?: string;
-        summary?: string;
-      };
-      expect(opts.urgency).toBe("high");
-      expect(opts.summary).toContain("web_search outage");
-    });
-
-    test("CAS false on complete suppresses failure feed event", async () => {
-      mockCompleteHeartbeatRun.mockImplementation(() => false);
-
-      const service = createService({
-        processMessage: async () => {
-          throw new Error("some error");
-        },
-      });
-
-      await service.runOnce();
-
-      const failCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { title?: string };
-          return opts.title === "Heartbeat Failed";
-        },
+      const failSignals = emittedNotificationSignals.filter(
+        (s) => s.sourceEventName === "activity.failed",
       );
-      expect(failCalls).toHaveLength(0);
+      expect(failSignals).toHaveLength(1);
+      const signal = failSignals[0]!;
+      expect(signal.contextPayload.jobName).toBe("heartbeat");
+      expect(signal.contextPayload.errorKind).toBe("exception");
+      expect(signal.contextPayload.errorMessage).toContain("web_search outage");
+      expect(signal.attentionHints?.urgency).toBe("medium");
+      expect(signal.attentionHints?.isAsyncBackground).toBe(true);
     });
 
-    test("timeout emits feed event with urgency high", async () => {
-      jest.useFakeTimers();
-      try {
-        let resolveRun: () => void;
-        const runPromise = new Promise<void>((r) => {
-          resolveRun = r;
-        });
-
-        const service = createService({
-          processMessage: async () => {
-            await runPromise;
-            return { messageId: "msg-1" };
-          },
-        });
-
-        const runOncePromise = service.runOnce();
-        jest.advanceTimersByTime(30 * 60 * 1000 + 1000);
-        await runOncePromise;
-
-        const timeoutCalls = mockEmitFeedEvent.mock.calls.filter(
-          (call: unknown[]) => {
-            const opts = call[0] as { title?: string };
-            return opts.title === "Heartbeat Timed Out";
-          },
-        );
-        expect(timeoutCalls).toHaveLength(1);
-        const opts = (timeoutCalls as any[][])[0][0] as {
-          urgency?: string;
-        };
-        expect(opts.urgency).toBe("high");
-
-        resolveRun!();
-      } finally {
-        jest.useRealTimers();
-      }
-    });
-
-    test("CAS false on timeout suppresses timeout feed event", async () => {
-      jest.useFakeTimers();
-      try {
-        mockCompleteHeartbeatRun.mockImplementation(() => false);
-
-        let resolveRun: () => void;
-        const runPromise = new Promise<void>((r) => {
-          resolveRun = r;
-        });
-
-        const service = createService({
-          processMessage: async () => {
-            await runPromise;
-            return { messageId: "msg-1" };
-          },
-        });
-
-        const runOncePromise = service.runOnce();
-        jest.advanceTimersByTime(30 * 60 * 1000 + 1000);
-        await runOncePromise;
-
-        // completeHeartbeatRun returned false, so no timeout feed event
-        const timeoutCalls = mockEmitFeedEvent.mock.calls.filter(
-          (call: unknown[]) => {
-            const opts = call[0] as { title?: string };
-            return opts.title === "Heartbeat Timed Out";
-          },
-        );
-        expect(timeoutCalls).toHaveLength(0);
-
-        resolveRun!();
-      } finally {
-        jest.useRealTimers();
-      }
-    });
-
-    test("late run emits late feed event", async () => {
-      const service = createService();
-      service.start();
-
-      // Set the pending run to be 10 minutes in the past
-      (service as any)._nextRunAt = Date.now() - 10 * 60 * 1000;
-      (service as any)._pendingRunId = "late-run-id";
-
-      await service.runOnce();
-
-      const lateCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { title?: string };
-          return opts.title === "Heartbeat Ran Late";
-        },
-      );
-      expect(lateCalls).toHaveLength(1);
-      const opts = (lateCalls as any[][])[0][0] as {
-        urgency?: string;
-        summary?: string;
-      };
-      expect(opts.urgency).toBe("medium");
-      expect(opts.summary).toContain("10 minutes late");
-
-      await service.stop();
-    });
-
-    test("on-time run does not emit late feed event", async () => {
-      const service = createService();
-      await service.runOnce();
-
-      const lateCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { title?: string };
-          return opts.title === "Heartbeat Ran Late";
-        },
-      );
-      expect(lateCalls).toHaveLength(0);
-    });
-
-    test("start() emits missed-run feed event when stale rows exist", () => {
+    test("start() emits activity.failed notification when stale rows exist", () => {
       mockMarkStaleRunsAsMissed.mockImplementation(() => 2);
       mockMarkStaleRunningAsError.mockImplementation(() => 1);
 
       const service = createService();
       service.start();
 
-      const missedCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { title?: string };
-          return opts.title === "Heartbeat Runs Missed";
-        },
+      const missedSignals = emittedNotificationSignals.filter(
+        (s) => s.sourceEventName === "activity.failed",
       );
-      expect(missedCalls).toHaveLength(1);
-      const opts = (missedCalls as any[][])[0][0] as {
-        urgency?: string;
-        summary?: string;
-      };
-      expect(opts.urgency).toBe("high");
-      expect(opts.summary).toContain("3");
+      expect(missedSignals).toHaveLength(1);
+      const signal = missedSignals[0]!;
+      expect(signal.dedupeKey).toContain("activity-failed:heartbeat-missed:");
+      expect(signal.contextPayload.jobName).toBe("heartbeat");
+      const errorMessage = signal.contextPayload.errorMessage as string;
+      expect(errorMessage).toContain("3");
+      expect(signal.attentionHints?.urgency).toBe("medium");
 
       service.stop();
     });
 
-    test("start() does not emit missed-run feed event when counts are 0", () => {
+    test("start() does not emit notification when counts are 0", () => {
       mockMarkStaleRunsAsMissed.mockImplementation(() => 0);
       mockMarkStaleRunningAsError.mockImplementation(() => 0);
 
       const service = createService();
       service.start();
 
-      const missedCalls = mockEmitFeedEvent.mock.calls.filter(
-        (call: unknown[]) => {
-          const opts = call[0] as { title?: string };
-          return opts.title === "Heartbeat Runs Missed";
-        },
+      const missedSignals = emittedNotificationSignals.filter(
+        (s) => s.sourceEventName === "activity.failed",
       );
-      expect(missedCalls).toHaveLength(0);
+      expect(missedSignals).toHaveLength(0);
       service.stop();
     });
   });

package/src/__tests__/history-repair.test.ts

@@ -724,6 +724,95 @@ describe("repairHistory", () => {
     expect(userMsg.content.every((b) => b.type !== "tool_result")).toBe(true);
   });
 
+  test("downgrades orphan web_search_tool_result in assistant message to text", () => {
+    // Inverse of the orphan-server_tool_use case. A web_search_tool_result
+    // in an assistant message whose tool_use_id has no preceding
+    // server_tool_use in the same message would 400 at the API. Downgrade
+    // to text so the model still sees the search results.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Here's what I found." },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_orphan",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://example.com",
+                title: "Example",
+                encrypted_content: "enc_abc",
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.orphanToolResultsDowngraded).toBe(1);
+    expect(stats.missingToolResultsInserted).toBe(0);
+
+    const assistantMsg = repaired[1];
+    expect(
+      assistantMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
+    const downgraded = assistantMsg.content.find(
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("srvtoolu_orphan"),
+    );
+    expect(downgraded).toBeDefined();
+  });
+
+  test("repairs both orphan directions within the same assistant message", () => {
+    // server_tool_use without a result AND a stray wsr from a different id —
+    // both must be repaired in one pass.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "go" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_missing_result",
+            name: "web_search",
+            input: { query: "alpha" },
+          },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_no_use",
+            content: [
+              { type: "web_search_result", url: "https://x.test", title: "X" },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(1);
+    expect(stats.orphanToolResultsDowngraded).toBe(1);
+
+    const assistantMsg = repaired[1];
+    // Synthetic result inserted immediately after the orphan server_tool_use.
+    const blockTypes = assistantMsg.content.map((b) => b.type);
+    expect(blockTypes[0]).toBe("server_tool_use");
+    expect(blockTypes[1]).toBe("web_search_tool_result");
+    expect(
+      (assistantMsg.content[1] as { tool_use_id: string }).tool_use_id,
+    ).toBe("stu_missing_result");
+    // The orphan wsr is downgraded to text.
+    expect(blockTypes[2]).toBe("text");
+    expect((assistantMsg.content[2] as { text: string }).text).toContain(
+      "stu_no_use",
+    );
+  });
+
   test("downgrades type-mismatched web_search_tool_result for tool_use", () => {
     // A web_search_tool_result paired with a regular tool_use ID is a type mismatch
     const messages: Message[] = [

package/src/__tests__/host-app-control-proxy.test.ts

@@ -3,6 +3,8 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 const sentMessages: unknown[] = [];
 const resolvedInteractionIds: string[] = [];
 let mockHasClient = false;
+// clientId → actorPrincipalId for the hub mock
+const mockActorMap = new Map<string, string>();
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: unknown) => sentMessages.push(msg),
@@ -11,11 +13,24 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       cap === "host_app_control" && mockHasClient
         ? { id: "mock-client" }
         : null,
+    getActorPrincipalIdForClient: (clientId: string) =>
+      mockActorMap.get(clientId),
   },
 }));
 
+interface RegisteredInteraction {
+  conversationId: string;
+  kind: string;
+  targetClientId?: string;
+  targetActorPrincipalId?: string;
+}
+const registeredInteractions: RegisteredInteraction[] = [];
+
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => undefined,
+  register: (
+    _requestId: string,
+    entry: RegisteredInteraction,
+  ) => registeredInteractions.push(entry),
   resolve: (requestId: string) => {
     resolvedInteractionIds.push(requestId);
     return undefined;
@@ -58,7 +73,9 @@ describe("HostAppControlProxy", () => {
   beforeEach(() => {
     sentMessages.length = 0;
     resolvedInteractionIds.length = 0;
+    registeredInteractions.length = 0;
     mockHasClient = false;
+    mockActorMap.clear();
     _resetActiveAppControlSession();
   });
 
@@ -769,4 +786,95 @@ describe("HostAppControlProxy", () => {
       proxy.dispose();
     });
   });
+
+  // -------------------------------------------------------------------------
+  // (g) sourceActorPrincipalId + targetClientId plumbing
+  // -------------------------------------------------------------------------
+
+  describe("actor principal + targetClientId plumbing", () => {
+    test("request() accepts sourceActorPrincipalId and targetClientId without crashing", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.app",
+      });
+
+      const resultPromise = proxy.request(
+        "app_control_observe",
+        { tool: "observe", app: "com.example.app" },
+        "conv-1",
+        ctrl.signal,
+        "actor-principal-1",    // sourceActorPrincipalId
+        "client-A",             // targetClientId
+      );
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_app_control_request");
+      // targetClientId propagates to the broadcast envelope
+      expect(sent.targetClientId).toBe("client-A");
+
+      // pending interactions registers targetClientId
+      expect(registeredInteractions).toHaveLength(1);
+      expect(registeredInteractions[0].targetClientId).toBe("client-A");
+
+      // Resolve to unblock the promise
+      proxy.resolve(sent.requestId as string, payload({ pngBase64: PNG_A }));
+      await resultPromise;
+
+      proxy.dispose();
+    });
+
+    test("request() with targetClientId + known actor: registers targetActorPrincipalId", async () => {
+      mockActorMap.set("client-A", "user-1");
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.app",
+      });
+
+      const resultPromise = proxy.request(
+        "app_control_observe",
+        { tool: "observe", app: "com.example.app" },
+        "conv-1",
+        ctrl.signal,
+        "user-1",    // sourceActorPrincipalId
+        "client-A",  // targetClientId → hub resolves actorPrincipalId = "user-1"
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      // targetActorPrincipalId was looked up from hub and stored
+      expect(registeredInteractions[0].targetActorPrincipalId).toBe("user-1");
+
+      proxy.resolve(sent.requestId as string, payload({ pngBase64: PNG_A }));
+      await resultPromise;
+
+      proxy.dispose();
+    });
+
+    test("request() without targetClientId: does not register targetActorPrincipalId", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const resultPromise = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.app" },
+        "conv-1",
+        ctrl.signal,
+        "user-1",    // sourceActorPrincipalId
+        undefined,   // no targetClientId
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(registeredInteractions[0].targetClientId).toBeUndefined();
+      expect(registeredInteractions[0].targetActorPrincipalId).toBeUndefined();
+
+      proxy.resolve(sent.requestId as string, payload({ pngBase64: PNG_A }));
+      await resultPromise;
+
+      proxy.dispose();
+    });
+  });
 });