@vellumai/assistant 0.12.1 → 0.12.2-dev.202609162314.7778bc8

package/src/__tests__/config-schema.test.ts

@@ -952,11 +952,7 @@ describe("AssistantConfigSchema", () => {
         enabled: true,
         text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',
       },
-      safety: {
-        denyCategories: [],
-      },
       voice: {
-        interruptSensitivity: "low",
         telephonyStreaming: true,
         utteranceEndMs: 1000,
       },
@@ -978,7 +974,6 @@ describe("AssistantConfigSchema", () => {
         maxDurationSeconds: 1800,
         userConsultTimeoutSeconds: 60,
         disclosure: { enabled: false, text: "Custom disclosure" },
-        safety: { denyCategories: ["spam"] },
       },
     });
     expect(result.calls.enabled).toBe(false);
@@ -986,7 +981,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.userConsultTimeoutSeconds).toBe(60);
     expect(result.calls.disclosure.enabled).toBe(false);
     expect(result.calls.disclosure.text).toBe("Custom disclosure");
-    expect(result.calls.safety.denyCategories).toEqual(["spam"]);
   });
 
   // ── Live voice config ───────────────────────────────────────────────
@@ -994,7 +988,6 @@ describe("AssistantConfigSchema", () => {
   test("applies liveVoice defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.liveVoice).toEqual({
-      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -1005,6 +998,18 @@ describe("AssistantConfigSchema", () => {
         echoEmaHalfLifeMs: 400,
         echoDrainSlackMs: 300,
       },
+      flux: {
+        turnEnd: { enabled: true },
+        eotThreshold: 0.7,
+        eotTimeoutMs: 5000,
+      },
+      archiveAudio: false,
+    });
+  });
+
+  test("applies voice defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.voice).toEqual({
       frontModel: {
         endpointDecisionTimeoutMs: 1200,
         endpointExtensionMs: 1500,
@@ -1016,38 +1021,27 @@ describe("AssistantConfigSchema", () => {
           maxSilenceMs: 35000,
           longOpMs: 15000,
           minGapMs: 6000,
-          generationTimeoutMs: 1500,
+          generationTimeoutMs: 5000,
         },
       },
-      flux: {
-        turnEnd: { enabled: true },
-        eotThreshold: 0.7,
-        eotTimeoutMs: 5000,
-      },
-      maxSessionDurationSeconds: 1800,
-      archiveAudio: false,
     });
   });
 
   test("accepts valid liveVoice config overrides", () => {
     const result = AssistantConfigSchema.parse({
       liveVoice: {
-        mode: "ptt",
         vad: {
           speechEnergyThreshold: 1500,
           silenceThresholdMs: 1000,
           bargeInMinSpeechMs: 120,
         },
-        maxSessionDurationSeconds: 900,
       },
     });
-    expect(result.liveVoice.mode).toBe("ptt");
     expect(result.liveVoice.vad.speechEnergyThreshold).toBe(1500);
     expect(result.liveVoice.vad.silenceThresholdMs).toBe(1000);
     expect(result.liveVoice.vad.bargeInMinSpeechMs).toBe(120);
     // Unspecified vad fields still get defaults
     expect(result.liveVoice.vad.maxTurnDurationMs).toBe(30000);
-    expect(result.liveVoice.maxSessionDurationSeconds).toBe(900);
     // A partial liveVoice override leaves Flux turn-end disabled by default.
     expect(result.liveVoice.flux.turnEnd.enabled).toBe(true);
   });
@@ -1136,18 +1130,10 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  test("rejects non-array calls.safety.denyCategories", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { safety: { denyCategories: "spam" } },
-    });
-    expect(result.success).toBe(false);
-  });
-
   // ── Calls voice config ──────────────────────────────────────────────
 
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.calls.voice.interruptSensitivity).toBe("low");
     expect(result.calls.voice.telephonyStreaming).toBe(true);
     expect(result.calls.voice.utteranceEndMs).toBe(1000);
   });
@@ -1165,9 +1151,23 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.voice.utteranceEndMs).toBe(2500);
   });
 
+  test("persisted calls configs carrying retired keys keep parsing", () => {
+    // Zod strips unrecognized keys, so a persisted config that still carries
+    // `calls.safety.denyCategories` or `calls.voice.interruptSensitivity`
+    // parses.
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        safety: { denyCategories: ["spam"] },
+        voice: { interruptSensitivity: "high" },
+      },
+    });
+    expect(result.calls).not.toHaveProperty("safety");
+    expect(result.calls.voice).not.toHaveProperty("interruptSensitivity");
+  });
+
   test("language is no longer part of the voice config schema", () => {
-    // The retired knob was read by nothing; Zod strips the unrecognized key
-    // so persisted configs that still carry it keep parsing.
+    // Zod strips the unrecognized key, so persisted configs that still carry
+    // it parse.
     const result = AssistantConfigSchema.parse({
       calls: { voice: { language: "es-ES" } },
     });
@@ -2633,7 +2633,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.maxDurationSeconds).toBe(3600);
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
-    expect(config.calls.safety.denyCategories).toEqual([]);
     expect(
       (config.calls.voice as Record<string, unknown>).language,
     ).toBeUndefined();

package/src/__tests__/config-sounds-sync.test.ts

@@ -5,6 +5,7 @@ import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
   publishConfigChanged,
+  publishMcpChanged,
   publishSchedulesChanged,
   publishSoundsConfigUpdated,
 } from "../runtime/sync/resource-sync-events.js";
@@ -94,4 +95,26 @@ describe("config and sounds sync events", () => {
       subscription.dispose();
     }
   });
+
+  test("MCP changes emit a sync tag without a client origin", async () => {
+    const received: AssistantEventEnvelope[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishMcpChanged();
+      await waitFor(() => received.length === 1);
+
+      expect(received[0].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.mcpList],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
 });

package/src/__tests__/config-watcher.test.ts

@@ -113,8 +113,11 @@ mock.module("../providers/registry.js", () => ({
   resolveProviderFromConnection: async () => null,
 }));
 
+let mcpReloadCallCount = 0;
 mock.module("../daemon/mcp-reload-service.js", () => ({
-  reloadMcpServers: async () => {},
+  reloadMcpServers: async () => {
+    mcpReloadCallCount += 1;
+  },
 }));
 
 mock.module("../signals/conversation-undo.js", () => ({
@@ -154,10 +157,6 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
-mock.module("../daemon/skill-memory-refresh.js", () => ({
-  refreshSkillCapabilityMemories: () => {},
-}));
-
 mock.module("../platform/sync-identity.js", () => ({
   syncIdentityNameToPlatform: () => {},
 }));
@@ -183,6 +182,7 @@ function findFileWatch(filePath: string): CapturedFileWatch | undefined {
 
 const WORKSPACE_FILES = new Set([
   "config.json",
+  "mcp.json",
   "SOUL.md",
   "IDENTITY.md",
   "ui/theme.json",
@@ -239,6 +239,7 @@ beforeEach(() => {
   evictCallCount = 0;
   identityCallCount = 0;
   themeCallCount = 0;
+  mcpReloadCallCount = 0;
   watcher = new ConfigWatcher(undefined, TEST_DEBOUNCE_MS);
 });
 
@@ -270,9 +271,9 @@ describe("ConfigWatcher workspace file handlers", () => {
 
   test("unregistered workspace files are not subscribed (only the registered handler set is)", () => {
     watcher.start();
-    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md,
-    // and ui/theme.json. The whole workspace dir must not be watched
-    // either — that was the ENXIO-on-Unix-sockets bug.
+    // Per-file watching only registers config.json, mcp.json, SOUL.md,
+    // IDENTITY.md, and ui/theme.json. The whole workspace dir must not
+    // be watched either: that was the ENXIO-on-Unix-sockets bug.
     expect(findFileWatch(join(WORKSPACE_DIR, "OTHER.md"))).toBeUndefined();
     expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
   });
@@ -285,6 +286,14 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(0);
   });
 
+  test("mcp.json change reloads MCP servers without evicting conversations", async () => {
+    watcher.start();
+    simulateFileChange(WORKSPACE_DIR, "mcp.json");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(mcpReloadCallCount).toBe(1);
+    expect(evictCallCount).toBe(0);
+  });
+
   test("config.json change calls refreshConfigFromSources", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {
@@ -332,6 +341,12 @@ describe("ConfigWatcher watcher lifecycle", () => {
     expect(findFileWatch(join(WORKSPACE_DIR, "IDENTITY.md"))).toBeDefined();
   });
 
+  test("start does not watch the skills directory", () => {
+    mkdirSync(join(WORKSPACE_DIR, "skills"), { recursive: true });
+    watcher.start();
+    expect(findWatcher(join(WORKSPACE_DIR, "skills"))).toBeUndefined();
+  });
+
   test("stop cancels pending debounce work, no eviction fires after", async () => {
     watcher.start();
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");

package/src/__tests__/connection-model-compat.test.ts

@@ -19,7 +19,7 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(
       isConnectionCompatibleWithModel(
         { auth: { type: "oauth_subscription" } as never },
-        "gpt-5.4",
+        "gpt-5.5",
       ),
     ).toBe(true);
   });
@@ -79,7 +79,7 @@ describe("describeSubscriptionModelIncompatibility", () => {
 
   test("returns null when model is Codex-compatible", () => {
     expect(
-      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.4"),
+      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.5"),
     ).toBeNull();
   });
 });

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -231,6 +231,8 @@ mock.module("../daemon/conversation-attachments.js", () => ({
     emittedAttachments: [],
     directiveWarnings: [],
     persistedFiles: [],
+    linkedAttachmentIds: [],
+    computerUseScreenshotAttachmentIds: [],
   }),
   approveHostAttachmentRead: async () => true,
   formatAttachmentWarnings: () => "",

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -340,6 +340,8 @@ const resolveAssistantAttachmentsMock = mock(async () => ({
   emittedAttachments: [],
   directiveWarnings: [],
   persistedFiles: [],
+  linkedAttachmentIds: [],
+  computerUseScreenshotAttachmentIds: [],
 }));
 mock.module("../daemon/conversation-attachments.js", () => ({
   resolveAssistantAttachments: resolveAssistantAttachmentsMock,

package/src/__tests__/conversation-agent-loop.test.ts

@@ -14,10 +14,12 @@ import {
 import type { LoopToolExecutor } from "../agent/loop.js";
 import type { AssistantEvent } from "../api/index.js";
 import { stripInjectionsForCompaction } from "../context/strip-injections.js";
+import type { AttachmentResolutionResult } from "../daemon/conversation-attachments.js";
 import {
   queueConversationNotice,
   resetConversationNoticesForTests,
 } from "../daemon/conversation-notices.js";
+import { desktopAutomationLease } from "../desktop/desktop-automation-lease.js";
 import { getConversationDirName } from "../persistence/conversation-directories.js";
 import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
@@ -42,6 +44,11 @@ const conversationDiskViewRealSnapshot = {
     "../persistence/conversation-disk-view.js",
   ) as Record<string, unknown>),
 };
+const channelReplyDeliveryRealSnapshot = {
+  ...(createRequire(import.meta.url)(
+    "../runtime/channel-reply-delivery.js",
+  ) as Record<string, unknown>),
+};
 // Disable the catalog default so resolution lands on llm.default.
 const disabledCatalogDefaultProfiles: Record<string, unknown> = {
   balanced: { source: "managed", status: "disabled" },
@@ -418,6 +425,10 @@ afterAll(() => {
     "../persistence/conversation-disk-view.js",
     () => conversationDiskViewRealSnapshot,
   );
+  mock.module(
+    "../runtime/channel-reply-delivery.js",
+    () => channelReplyDeliveryRealSnapshot,
+  );
 });
 
 const syncMessageToDiskMock = mock(() => {});
@@ -428,6 +439,19 @@ mock.module("../persistence/conversation-disk-view.js", () => ({
     rebuildConversationDiskViewFromDbStateMock,
 }));
 
+let mockTurnReplyMessageId: string | undefined;
+const resolveTurnReplyMessageIdMock = mock(
+  (
+    _conversationId: string,
+    _userMessageId: string | undefined,
+    fallbackMessageId: string,
+  ) => mockTurnReplyMessageId ?? fallbackMessageId,
+);
+mock.module("../runtime/channel-reply-delivery.js", () => ({
+  ...channelReplyDeliveryRealSnapshot,
+  resolveTurnReplyMessageId: resolveTurnReplyMessageIdMock,
+}));
+
 mock.module("../apps/app-store.js", () => ({
   getApp: () => null,
   listAppFiles: () => [],
@@ -580,12 +604,16 @@ mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
 
-const resolveAssistantAttachmentsMock = mock(async () => ({
-  assistantAttachments: [],
-  emittedAttachments: [],
-  directiveWarnings: [],
-  persistedFiles: [],
-}));
+const resolveAssistantAttachmentsMock = mock(
+  async (): Promise<AttachmentResolutionResult> => ({
+    assistantAttachments: [],
+    emittedAttachments: [],
+    directiveWarnings: [],
+    persistedFiles: [],
+    linkedAttachmentIds: [],
+    computerUseScreenshotAttachmentIds: [],
+  }),
+);
 mock.module("../daemon/conversation-attachments.js", () => ({
   resolveAssistantAttachments: resolveAssistantAttachmentsMock,
   approveHostAttachmentRead: async () => true,
@@ -894,6 +922,26 @@ function makeCtx(
   return ctx;
 }
 
+function makeSendUserMessageCtx(): Conversation {
+  return makeCtx({
+    currentCallSite: "mainAgent",
+    providerResponses: [
+      toolUseResponse("tu_1", "send_user_message", {
+        message: "Here is the result.",
+      }),
+      textResponse("Finished delivery."),
+    ],
+    loopTools: [
+      {
+        name: "send_user_message",
+        description: "deliver",
+        input_schema: { type: "object" },
+      },
+    ],
+    toolExecutor: async () => ({ content: "Delivered.", isError: false }),
+  });
+}
+
 /**
  * What `classifyConversationError` returns for a daily-credit-limit 402 (see
  * `dailyLimitClassification` in conversation-error.ts). Its `userMessage` is
@@ -987,6 +1035,8 @@ beforeEach(() => {
   setAgentLoopExitReasonOnLatestLogMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
+  mockTurnReplyMessageId = undefined;
+  resolveTurnReplyMessageIdMock.mockClear();
   emitAssistantReplyNotificationMock.mockClear();
   updateMessageMetadataMock.mockClear();
   updateMessageMetadataMock.mockImplementation(() => {});
@@ -1038,6 +1088,8 @@ beforeEach(() => {
     emittedAttachments: [],
     directiveWarnings: [],
     persistedFiles: [],
+    linkedAttachmentIds: [],
+    computerUseScreenshotAttachmentIds: [],
   }));
   mockMessageById = null;
   resetConversationNoticesForTests();
@@ -1663,6 +1715,30 @@ describe("session-agent-loop", () => {
     });
   });
 
+  test("releases desktop control before a completed turn accepts another message", async () => {
+    const events: AssistantEvent[] = [];
+    const ctx = makeCtx();
+    const release = spyOn(desktopAutomationLease, "releaseForConversation");
+    const setProcessing = ctx.setProcessing.bind(ctx);
+    ctx.setProcessing = (processing) => {
+      if (!processing) {
+        expect(release).toHaveBeenCalledWith(ctx.conversationId);
+      }
+      setProcessing(processing);
+    };
+    try {
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (event) =>
+        events.push(event),
+      );
+      expect(events.some((event) => event.type === "message_complete")).toBe(
+        true,
+      );
+      expect(release).toHaveBeenCalledTimes(1);
+    } finally {
+      release.mockRestore();
+    }
+  });
+
   describe("tool execution errors via agent loop", () => {
     test("error events from agent loop are classified and emitted", async () => {
       const events: AssistantEvent[] = [];
@@ -1698,6 +1774,139 @@ describe("session-agent-loop", () => {
       const complete = events.find((e) => e.type === "message_complete");
       expect(complete).toBeDefined();
     });
+
+    test("carries automatic screenshot provenance on message completion", async () => {
+      resolveAssistantAttachmentsMock.mockImplementation(async () => ({
+        assistantAttachments: [],
+        emittedAttachments: [
+          {
+            id: "screenshot-1",
+            filename: "computer-use-click.png",
+            mimeType: "image/png",
+            data: "c2NyZWVuc2hvdA==",
+            sourceType: "tool_block" as const,
+            computerUseScreenshot: true,
+          },
+        ],
+        directiveWarnings: [],
+        persistedFiles: [],
+        linkedAttachmentIds: ["screenshot-1"],
+        computerUseScreenshotAttachmentIds: ["screenshot-1"],
+      }));
+      const events: AssistantEvent[] = [];
+      const ctx = makeCtx({ providerResponses: [textResponse("Done")] });
+
+      await runAgentLoopImpl(ctx, "click it", "msg-1", (event) =>
+        events.push(event),
+      );
+
+      const complete = events.find(
+        (event) => event.type === "message_complete",
+      );
+      expect(complete?.attachments?.[0]?.computerUseScreenshot).toBe(true);
+      const syncCalls = syncMessageToDiskMock.mock.calls as unknown as Array<
+        [string, string, number]
+      >;
+      const finalRowSyncs = syncCalls.filter(
+        (call) => call[1] === "msg-reserve",
+      );
+      expect(finalRowSyncs).toHaveLength(1);
+    });
+
+    test("defers an earlier delivered attachment reply to ordered turn settlement", async () => {
+      const featureFlags = await import("../config/assistant-feature-flags.js");
+      const flagSpy = spyOn(
+        featureFlags,
+        "isAssistantFeatureFlagEnabled",
+      ).mockImplementation((key: string) => key === "send-user-message");
+      reserveMessageMock
+        .mockImplementationOnce(async () => ({ id: "msg-delivered-reply" }))
+        .mockImplementationOnce(async () => ({ id: "msg-tool-result" }))
+        .mockImplementationOnce(async () => ({ id: "msg-final-private" }));
+      mockTurnReplyMessageId = "msg-delivered-reply";
+      resolveAssistantAttachmentsMock.mockImplementation(async () => ({
+        assistantAttachments: [],
+        emittedAttachments: [],
+        directiveWarnings: [],
+        persistedFiles: [],
+        linkedAttachmentIds: ["attachment-1"],
+        computerUseScreenshotAttachmentIds: [],
+      }));
+      const assistantSyncsAtTerminal: string[][] = [];
+      const ctx = makeSendUserMessageCtx();
+
+      try {
+        await runAgentLoopImpl(ctx, "click it", "msg-1", (event) => {
+          if (event.type !== "message_complete") {
+            return;
+          }
+          const calls = syncMessageToDiskMock.mock.calls as unknown as Array<
+            [string, string, number]
+          >;
+          assistantSyncsAtTerminal.push(
+            calls
+              .map((call) => call[1])
+              .filter((id) =>
+                ["msg-delivered-reply", "msg-final-private"].includes(id),
+              ),
+          );
+        });
+      } finally {
+        flagSpy.mockRestore();
+      }
+
+      expect(resolveTurnReplyMessageIdMock).toHaveBeenCalledWith(
+        "test-conv",
+        "msg-1",
+        "msg-final-private",
+      );
+      expect(assistantSyncsAtTerminal.at(-1)).toEqual([]);
+      const calls = syncMessageToDiskMock.mock.calls as unknown as Array<
+        [string, string, number]
+      >;
+      expect(
+        calls
+          .map((call) => call[1])
+          .filter((id) =>
+            ["msg-delivered-reply", "msg-final-private"].includes(id),
+          ),
+      ).toEqual(["msg-delivered-reply", "msg-final-private"]);
+    });
+
+    test("does not queue an earlier delivered reply without a linked attachment", async () => {
+      const featureFlags = await import("../config/assistant-feature-flags.js");
+      const flagSpy = spyOn(
+        featureFlags,
+        "isAssistantFeatureFlagEnabled",
+      ).mockImplementation((key: string) => key === "send-user-message");
+      reserveMessageMock
+        .mockImplementationOnce(async () => ({ id: "msg-delivered-empty" }))
+        .mockImplementationOnce(async () => ({ id: "msg-tool-result-empty" }))
+        .mockImplementationOnce(async () => ({ id: "msg-final-empty" }));
+      mockTurnReplyMessageId = "msg-delivered-empty";
+
+      try {
+        await runAgentLoopImpl(
+          makeSendUserMessageCtx(),
+          "click it",
+          "msg-1",
+          () => {},
+        );
+      } finally {
+        flagSpy.mockRestore();
+      }
+
+      const calls = syncMessageToDiskMock.mock.calls as unknown as Array<
+        [string, string, number]
+      >;
+      expect(
+        calls
+          .map((call) => call[1])
+          .filter((id) =>
+            ["msg-delivered-empty", "msg-final-empty"].includes(id),
+          ),
+      ).toEqual(["msg-final-empty"]);
+    });
   });
 
   describe("LLM request log persistence", () => {
@@ -2172,6 +2381,48 @@ describe("session-agent-loop", () => {
       );
     });
 
+    test("carries automatic screenshot provenance on generation handoff", async () => {
+      resolveAssistantAttachmentsMock.mockImplementation(async () => ({
+        assistantAttachments: [],
+        emittedAttachments: [
+          {
+            id: "screenshot-1",
+            filename: "computer-use-click.png",
+            mimeType: "image/png",
+            data: "c2NyZWVuc2hvdA==",
+            sourceType: "tool_block" as const,
+            computerUseScreenshot: true,
+          },
+        ],
+        directiveWarnings: [],
+        persistedFiles: [],
+        linkedAttachmentIds: ["screenshot-1"],
+        computerUseScreenshotAttachmentIds: ["screenshot-1"],
+      }));
+      const events: AssistantEvent[] = [];
+      const ctx = makeCtx({
+        providerResponses: [toolUseResponse("tu-1", "file_read", {})],
+        loopTools: [
+          {
+            name: "file_read",
+            description: "Read a file",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+        toolExecutor: async () => ({ content: "content", isError: false }),
+        canHandoffAtCheckpoint: () => true,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (event) =>
+        events.push(event),
+      );
+
+      const handoff = events.find(
+        (event) => event.type === "generation_handoff",
+      );
+      expect(handoff?.attachments?.[0]?.computerUseScreenshot).toBe(true);
+    });
+
     test("continues when canHandoffAtCheckpoint returns false", async () => {
       const events: AssistantEvent[] = [];