@vellumai/assistant 0.8.0 → 0.8.2

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__/helpers/tar-fixtures.ts

@@ -0,0 +1,39 @@
+export function makeTarEntry(name: string, content: string): Buffer {
+  const header = Buffer.alloc(512, 0);
+  const nameBuffer = Buffer.from(name, "utf-8");
+  nameBuffer.copy(header, 0, 0, Math.min(nameBuffer.length, 100));
+
+  Buffer.from("0000644\0", "ascii").copy(header, 100);
+  Buffer.from("0000000\0", "ascii").copy(header, 108);
+  Buffer.from("0000000\0", "ascii").copy(header, 116);
+  Buffer.from(
+    `${content.length.toString(8).padStart(11, "0")}\0`,
+    "ascii",
+  ).copy(header, 124);
+  Buffer.from("00000000000\0", "ascii").copy(header, 136);
+  Buffer.from("        ", "ascii").copy(header, 148);
+  header[156] = "0".charCodeAt(0);
+  Buffer.from("ustar\0", "ascii").copy(header, 257);
+  Buffer.from("00", "ascii").copy(header, 263);
+
+  let sum = 0;
+  for (let i = 0; i < 512; i += 1) sum += header[i] ?? 0;
+  Buffer.from(`${sum.toString(8).padStart(6, "0")}\0 `, "ascii").copy(
+    header,
+    148,
+  );
+
+  const data = Buffer.from(content, "utf-8");
+  const padded = Buffer.alloc(Math.ceil(data.length / 512) * 512, 0);
+  data.copy(padded);
+  return Buffer.concat([header, padded]);
+}
+
+export function makeTar(
+  entries: Array<{ name: string; content: string }>,
+): Buffer {
+  return Buffer.concat([
+    ...entries.map((entry) => makeTarEntry(entry.name, entry.content)),
+    Buffer.alloc(1024, 0),
+  ]);
+}

package/src/__tests__/helpers/wait-for.ts

@@ -0,0 +1,21 @@
+export async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    message?: string;
+  } = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 500;
+  const intervalMs = options.intervalMs ?? 5;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  throw new Error(options.message ?? "Timed out waiting for test condition");
+}

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

@@ -248,7 +248,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "observer-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: observer },
     });
@@ -297,7 +296,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "override-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: shortCircuit },
     });
@@ -342,7 +340,6 @@ describe("historyRepair pipeline — end-to-end via runPipeline", () => {
       manifest: {
         name: "late-user-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", historyRepairApi: "v1" },
       },
       middleware: { historyRepair: userMiddleware },
     });

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

@@ -724,6 +724,168 @@ 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();
+    // Titles/URLs from the original results must survive the downgrade so
+    // the model can still reason about what was searched.
+    const text = (downgraded as { text: string }).text;
+    expect(text).toContain("Example");
+    expect(text).toContain("https://example.com");
+  });
+
+  test("preserves all titles/URLs when downgrading multi-result orphan", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_multi",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://alpha.test",
+                title: "Alpha",
+                encrypted_content: "enc_a",
+              },
+              {
+                type: "web_search_result",
+                url: "https://beta.test",
+                title: "Beta",
+                encrypted_content: "enc_b",
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired } = repairHistory(messages);
+    const downgraded = repaired[1].content.find((b) => b.type === "text") as
+      | { text: string }
+      | undefined;
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("Alpha");
+    expect(downgraded!.text).toContain("https://alpha.test");
+    expect(downgraded!.text).toContain("Beta");
+    expect(downgraded!.text).toContain("https://beta.test");
+    // Must NOT emit the legacy fixed placeholder.
+    expect(downgraded!.text).not.toContain("[web search result]");
+  });
+
+  test("downgrades error-envelope web_search orphan to a stable marker", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_err",
+            content: {
+              type: "web_search_tool_result_error",
+              error_code: "unavailable",
+            },
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired } = repairHistory(messages);
+    const downgraded = repaired[1].content.find((b) => b.type === "text") as
+      | { text: string }
+      | undefined;
+    expect(downgraded).toBeDefined();
+    expect(downgraded!.text).toContain("srvtoolu_err");
+    expect(downgraded!.text).toContain("results unavailable");
+  });
+
+  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[] = [