@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -5,17 +5,16 @@
  * One representative call site (the `installSkill` bundled branch) is
  * exercised — all 5 sites share the same delegation to
  * `maybeSeedMemoryV2Skills`, so a single suite covers behavior. Validates:
- *   - flag + config both on → helper invoked after seedSkillGraphNodes
- *     and the seed observed (callOrder picks up "v2")
- *   - flag off → helper still invoked, but the seed short-circuits
- *   - config.memory.v2.enabled off → helper still invoked, seed short-circuits
+ *   - config on → helper invoked after seedSkillGraphNodes and the seed
+ *     observed (callOrder picks up "v2")
+ *   - config off → helper still invoked, but the seed short-circuits
  *
  * The handler delegates to `maybeSeedMemoryV2Skills` from
  * `daemon/memory-v2-startup.ts`. We mock that module directly so the test
  * does not have to drain the dynamic-import microtask chain. The helper's
- * gate semantics (flag + config + rejection swallowing) are covered by
- * `lifecycle-memory-v2-seed.test.ts`; here we only verify that the
- * handler invokes the helper synchronously with the live config.
+ * gate semantics are covered by `lifecycle-memory-v2-seed.test.ts`; here
+ * we only verify that the handler invokes the helper synchronously with
+ * the live config.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -23,7 +22,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // Programmable test state
 // ---------------------------------------------------------------------------
 
-const flagsState = { flagEnabled: true, configV2Enabled: true };
+const flagsState = { configV2Enabled: true };
 
 const callOrder: string[] = [];
 
@@ -55,10 +54,7 @@ mock.module("../config/skills.js", () => ({
 }));
 
 mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) => {
-    if (key === "memory-v2-enabled") return flagsState.flagEnabled;
-    return true;
-  },
+  isAssistantFeatureFlagEnabled: () => true,
 }));
 
 // Stub both `getConfig` and `loadConfig`. `loadConfig` is reached by code
@@ -220,18 +216,17 @@ const { installSkill } = await import("../daemon/handlers/skills.js");
 
 describe("v2 skill re-seed gating in skill handlers", () => {
   beforeEach(() => {
-    flagsState.flagEnabled = true;
     flagsState.configV2Enabled = true;
     callOrder.length = 0;
     mockSeedSkillGraphNodes.mockClear();
     mockMaybeSeedMemoryV2Skills.mockClear();
     mockMaybeSeedMemoryV2Skills.mockImplementation((config) => {
-      if (!flagsState.flagEnabled || !config.memory.v2.enabled) return;
+      if (!config.memory.v2.enabled) return;
       callOrder.push("v2");
     });
   });
 
-  test("flag + config both on → maybeSeedMemoryV2Skills invoked after seedSkillGraphNodes", async () => {
+  test("config on → maybeSeedMemoryV2Skills invoked after seedSkillGraphNodes", async () => {
     const result = await installSkill({ slug: "bundled-skill" });
 
     expect(result.success).toBe(true);
@@ -240,17 +235,6 @@ describe("v2 skill re-seed gating in skill handlers", () => {
     expect(callOrder).toEqual(["v1", "v2"]);
   });
 
-  test("flag off → seed mock observes the disabled flag and skips", async () => {
-    flagsState.flagEnabled = false;
-
-    const result = await installSkill({ slug: "bundled-skill" });
-
-    expect(result.success).toBe(true);
-    expect(mockSeedSkillGraphNodes).toHaveBeenCalledTimes(1);
-    expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["v1"]);
-  });
-
   test("config.memory.v2.enabled off → seed mock observes config and skips", async () => {
     flagsState.configV2Enabled = false;
 
@@ -261,12 +245,4 @@ describe("v2 skill re-seed gating in skill handlers", () => {
     expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
     expect(callOrder).toEqual(["v1"]);
   });
-
-  // Note: "seed rejection swallowed" is now an internal concern of
-  // `maybeSeedMemoryV2Skills` — it dispatches the seed call as a
-  // fire-and-forget promise with `.catch(log.warn)`. That behavior is
-  // covered by `lifecycle-memory-v2-seed.test.ts`. From the handler's
-  // perspective, we only need to verify the helper is invoked
-  // synchronously with the correct config — which the cases above already
-  // exercise.
 });

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

@@ -1,5 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// Default the warm-pool gate to OPEN — these tests probe disk-pressure
+// behavior, not the pre-first-message guard.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -63,6 +70,10 @@ mock.module("../memory/conversation-crud.js", () => ({
     createdConversations.push(opts);
     return { id: "conv-1", ...opts };
   },
+  // runBackgroundJob (loaded transitively via heartbeat-service) imports
+  // addMessage. Disk-pressure short-circuits before addMessage ever runs,
+  // but the mock module must still expose every name the real module does.
+  addMessage: () => Promise.resolve({ id: "mock-msg-id" }),
 }));
 
 const mockProcessMessage = mock(() => Promise.resolve({ messageId: "msg-1" }));
@@ -70,9 +81,11 @@ mock.module("../daemon/process-message.js", () => ({
   processMessage: mockProcessMessage,
 }));
 
-const mockEmitFeedEvent = mock(() => Promise.resolve());
-mock.module("../home/emit-feed-event.js", () => ({
-  emitFeedEvent: mockEmitFeedEvent,
+const emittedNotificationSignals: Array<{ sourceEventName?: string }> = [];
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (opts: { sourceEventName?: string }) => {
+    emittedNotificationSignals.push({ sourceEventName: opts.sourceEventName });
+  },
 }));
 
 mock.module("../prompts/persona-resolver.js", () => ({
@@ -131,10 +144,10 @@ describe("HeartbeatService disk pressure gate", () => {
     mockMarkStaleRunningAsError.mockClear();
     mockMarkStaleRunningAsError.mockImplementation(() => 0);
     mockProcessMessage.mockClear();
-    mockEmitFeedEvent.mockClear();
+    emittedNotificationSignals.length = 0;
   });
 
-  test("skips without creating heartbeat rows, conversations, or feed events", async () => {
+  test("skips without creating heartbeat rows, conversations, or notifications", async () => {
     const service = new HeartbeatService({
       alerter: () => {},
     });
@@ -148,7 +161,7 @@ describe("HeartbeatService disk pressure gate", () => {
     expect(mockSkipHeartbeatRun).not.toHaveBeenCalled();
     expect(createdConversations).toHaveLength(0);
     expect(mockProcessMessage).not.toHaveBeenCalled();
-    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
+    expect(emittedNotificationSignals).toHaveLength(0);
   });
 
   test("allows forced user-initiated heartbeat runs while locked", async () => {
@@ -168,7 +181,7 @@ describe("HeartbeatService disk pressure gate", () => {
     expect(mockProcessMessage).toHaveBeenCalledTimes(1);
   });
 
-  test("start recovery skips missed-run feed events while locked", async () => {
+  test("start recovery skips missed-run notifications while locked", async () => {
     mockMarkStaleRunsAsMissed.mockImplementationOnce(() => 1);
     const service = new HeartbeatService({
       alerter: () => {},
@@ -178,6 +191,6 @@ describe("HeartbeatService disk pressure gate", () => {
     await service.stop();
 
     expect(mockMarkStaleRunsAsMissed).toHaveBeenCalledTimes(1);
-    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
+    expect(emittedNotificationSignals).toHaveLength(0);
   });
 });

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[] = [