@vellumai/assistant 0.12.2-staging.1 → 0.12.2-staging.3

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -6,8 +6,19 @@
  * state or the daemon conversation store.
  */
 
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
+import {
+  afterAll,
+  afterEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+
+import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
+import * as desktopFeature from "../../desktop/virtual-desktop-feature.js";
+import { browserManager } from "../../tools/browser/browser-manager.js";
 import type { ToolExecutionResult } from "../../tools/types.js";
 
 // ---------------------------------------------------------------------------
@@ -31,7 +42,10 @@ let mockOperationCalls: Array<{
 let mockConversation: {
   trustContext?: { trustClass: string };
   transportInterface?: string;
+  currentTurnClientOs?: string;
+  clientOs?: string;
   getTurnActorPrincipalId?: () => string | undefined;
+  abortController?: AbortController;
 } | null = null;
 
 let mockFindConversationCalls: string[] = [];
@@ -66,6 +80,47 @@ mock.module("../../daemon/conversation-registry.js", () => ({
   },
 }));
 
+let desktopEnabled = false;
+let desktopReady = false;
+let desktopFailure = false;
+const enabledSpy = spyOn(
+  desktopFeature,
+  "isVirtualDesktopEnabled",
+).mockImplementation(() => desktopEnabled);
+const readySpy = spyOn(
+  desktopDependencyInstaller,
+  "getStatus",
+).mockImplementation(() => ({ state: desktopReady ? "ready" : "required" }));
+afterAll(() => {
+  enabledSpy.mockRestore();
+  readySpy.mockRestore();
+});
+
+let desktopContext: import("../../tools/types.js").ToolContext | undefined;
+mock.module("../../desktop/desktop-browser-operations.js", () => ({
+  executeDesktopBrowserTabs: async (
+    _params: unknown,
+    context: import("../../tools/types.js").ToolContext,
+  ) => {
+    desktopContext = context;
+    return {
+      content: JSON.stringify({ ok: true, tabs: [{ tabId: 1 }] }),
+      isError: false,
+    };
+  },
+  executeDesktopBrowserOperation: async (
+    _operation: string,
+    _input: Record<string, unknown>,
+    context: import("../../tools/types.js").ToolContext,
+  ) => {
+    desktopContext = context;
+    return {
+      content: desktopFailure ? "Desktop is busy" : "desktop",
+      isError: desktopFailure,
+    };
+  },
+}));
+
 // Import after mocking — now from the shared routes location
 const { ROUTES, browserCliConversationKey } =
   await import("../../runtime/routes/browser-routes.js");
@@ -92,6 +147,11 @@ function callHandler(
 // ---------------------------------------------------------------------------
 
 afterEach(() => {
+  desktopEnabled = false;
+  desktopReady = false;
+  desktopFailure = false;
+  desktopContext = undefined;
+  browserManager.clearPreferredBackendKind("conv-default-browser");
   mockOperationResult = { content: "ok", isError: false };
   mockOperationCalls = [];
   mockConversation = null;
@@ -422,3 +482,171 @@ describe("browser_execute route", () => {
     expect(mockOperationCalls[0].input).toEqual({});
   });
 });
+
+test("desktop route preserves guardian ownership and live-turn cancellation", async () => {
+  const abortController = new AbortController();
+  mockConversation = {
+    trustContext: { trustClass: "guardian" },
+    getTurnActorPrincipalId: () => "user-123",
+    abortController,
+  };
+  const result = await callHandler(
+    { operation: "snapshot", desktop: true, conversationId: "conv-desktop" },
+    { "x-vellum-actor-principal-id": "user-other" },
+  );
+  expect(result).toMatchObject({ content: "desktop" });
+  expect(mockOperationCalls).toHaveLength(0);
+  expect(desktopContext).toMatchObject({
+    conversationId: "conv-desktop",
+    sourceActorPrincipalId: "user-123",
+    trustClass: "guardian",
+  });
+  expect(desktopContext?.signal?.aborted).toBe(false);
+  abortController.abort();
+  expect(desktopContext?.signal?.aborted).toBe(true);
+});
+
+function webConversation(clientOs = "web") {
+  desktopEnabled = true;
+  desktopReady = true;
+  mockConversation = {
+    trustContext: { trustClass: "guardian" },
+    transportInterface: "web",
+    currentTurnClientOs: clientOs,
+    getTurnActorPrincipalId: () => "user-123",
+  };
+}
+
+test("web browser commands default to the installed streamed Chrome", async () => {
+  webConversation();
+  const result = await callHandler({
+    operation: "navigate",
+    input: { url: "https://example.com" },
+    conversationId: "conv-default-browser",
+  });
+  expect(result).toMatchObject({ content: "desktop", isError: false });
+  expect(mockOperationCalls).toHaveLength(0);
+  expect(desktopContext?.clientOs).toBe("web");
+});
+
+test.each(["macos", "windows"])(
+  "%s renderer uses the personal browser despite its web transport",
+  async (clientOs) => {
+    webConversation(clientOs);
+    await callHandler({
+      operation: "snapshot",
+      conversationId: "conv-default-browser",
+    });
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(desktopContext).toBeUndefined();
+  },
+);
+
+test("browser selection uses the active turn rather than a queued message's OS", async () => {
+  webConversation("macos");
+  mockConversation!.clientOs = "web";
+  await callHandler({
+    operation: "snapshot",
+    conversationId: "conv-default-browser",
+  });
+  expect(mockOperationCalls).toHaveLength(1);
+  expect(desktopContext).toBeUndefined();
+});
+
+test.each(["flag", "guardian", "actor"])(
+  "web preserves the existing browser when %s is unavailable",
+  async (missing) => {
+    webConversation();
+    if (missing === "flag") {
+      desktopEnabled = false;
+    }
+    if (missing === "guardian") {
+      mockConversation!.trustContext = { trustClass: "unknown" };
+    }
+    if (missing === "actor") {
+      mockConversation!.getTurnActorPrincipalId = () => undefined;
+    }
+    await callHandler({
+      operation: "snapshot",
+      conversationId: "conv-default-browser",
+    });
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(desktopContext).toBeUndefined();
+  },
+);
+
+test.each([
+  { browser_mode: "local" },
+  { browser_mode: "playwright" },
+  { browser_mode: "extension" },
+  { browser_mode: "cdp-inspect" },
+  { target_client_id: "client-123" },
+  { use_active_tab: true },
+])("explicit browser choice %j wins over the web default", async (input) => {
+  webConversation();
+  await callHandler({
+    operation: "snapshot",
+    input,
+    conversationId: "conv-default-browser",
+  });
+  expect(mockOperationCalls).toHaveLength(1);
+  expect(desktopContext).toBeUndefined();
+});
+
+test("follow-up web commands retain an existing personal browser session", async () => {
+  webConversation();
+  browserManager.setPreferredBackendKind("conv-default-browser", "extension");
+  await callHandler({
+    operation: "snapshot",
+    conversationId: "conv-default-browser",
+  });
+  expect(mockOperationCalls).toHaveLength(1);
+  expect(desktopContext).toBeUndefined();
+});
+
+test("native clients can explicitly select the streamed browser", async () => {
+  webConversation("windows");
+  const result = await callHandler({
+    operation: "snapshot",
+    desktop: true,
+    conversationId: "conv-default-browser",
+  });
+  expect(result).toMatchObject({ content: "desktop" });
+  expect(desktopContext?.clientOs).toBe("windows");
+  expect(mockOperationCalls).toHaveLength(0);
+});
+
+test("web tab commands share the streamed browser default", async () => {
+  webConversation();
+  const { ROUTES } =
+    await import("../../runtime/routes/browser-tabs-routes.js");
+  const result = await ROUTES[0].handler({
+    body: { command: "list", conversationId: "conv-default-browser" },
+  });
+  expect(result).toEqual({ ok: true, tabs: [{ tabId: 1 }] });
+  expect(desktopContext?.clientOs).toBe("web");
+});
+
+test("a streamed browser failure does not switch to Playwright or personal Chrome", async () => {
+  webConversation();
+  desktopFailure = true;
+  const result = await callHandler({
+    operation: "click",
+    input: { selector: "#submit" },
+    conversationId: "conv-default-browser",
+  });
+  expect(result).toMatchObject({ isError: true, content: "Desktop is busy" });
+  expect(mockOperationCalls).toHaveLength(0);
+});
+
+test("first web browser use routes to virtual desktop setup before installation", async () => {
+  webConversation();
+  desktopReady = false;
+  await callHandler({
+    operation: "navigate",
+    input: { url: "https://example.com" },
+    conversationId: "conv-default-browser",
+  });
+  expect(desktopContext?.clientOs).toBe("web");
+  expect(mockOperationCalls).toHaveLength(0);
+});

package/src/ipc/__tests__/cancel-on-disconnect.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, expect, test } from "bun:test";
+
+import { setDbReady } from "../../daemon/daemon-readiness.js";
+import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
+import { AssistantIpcServer } from "../assistant-server.js";
+import { cliIpcCall } from "../cli-client.js";
+
+let server: AssistantIpcServer | undefined;
+afterEach(() => server?.stop());
+
+for (const cancelOnDisconnect of [true, false]) {
+  test(`timed-out IPC request cancels its action only when opted in: ${cancelOnDisconnect}`, async () => {
+    setDbReady(true);
+    server = new AssistantIpcServer();
+    const methods = (
+      server as unknown as {
+        methods: Map<string, (args: RouteHandlerArgs) => Promise<unknown>>;
+      }
+    ).methods;
+    const setup = Promise.withResolvers<void>();
+    const completed = Promise.withResolvers<void>();
+    let signal: AbortSignal | undefined;
+    let actions = 0;
+    methods.set("test_browser_setup", async (args) => {
+      signal = args.abortSignal;
+      await setup.promise;
+      if (!signal?.aborted) {
+        actions++;
+      }
+      completed.resolve();
+      return { ok: true };
+    });
+    await server.start();
+    try {
+      const result = await cliIpcCall(
+        "test_browser_setup",
+        {},
+        {
+          timeoutMs: 100,
+          cancelOnDisconnect,
+        },
+      );
+      expect(result.timedOut).toBe(true);
+      expect(signal).toBeDefined();
+      await Bun.sleep(20);
+      setup.resolve();
+      await completed.promise;
+      expect(signal?.aborted).toBe(cancelOnDisconnect);
+      expect(actions).toBe(cancelOnDisconnect ? 0 : 1);
+    } finally {
+      setup.resolve();
+    }
+  });
+}

package/src/ipc/assistant-server.ts

@@ -78,6 +78,7 @@ const log = getLogger("assistant-ipc-server");
 // ---------------------------------------------------------------------------
 
 export type IpcRequest = {
+  cancelOnDisconnect?: boolean;
   id: string;
   method: string;
   params?: Record<string, unknown>;
@@ -404,6 +405,16 @@ export class AssistantIpcServer {
       this.abortControllers.set(req.id, abortController);
     }
 
+    const onDisconnect = () => abortController?.abort();
+    if (req.cancelOnDisconnect === true) {
+      socket.once("close", onDisconnect);
+    }
+    const removeDisconnectListener = () => {
+      if (req.cancelOnDisconnect === true) {
+        socket.off("close", onDisconnect);
+      }
+    };
+
     try {
       const handlerArgs = {
         ...injectLocalActorHeader(req.params),
@@ -434,14 +445,17 @@ export class AssistantIpcServer {
               reader,
               this.buildErrorResponse(req.id, err),
             );
-          });
+          })
+          .finally(removeDisconnectListener);
       } else {
+        removeDisconnectListener();
         if (!isIpcStreamingResponse(result)) {
           this.abortControllers.delete(req.id);
         }
         this.sendResult(socket, reader, req.id, result);
       }
     } catch (err) {
+      removeDisconnectListener();
       this.abortControllers.delete(req.id);
       log.warn({ err, method: req.method }, "IPC handler error");
       this.sendResponse(socket, reader, this.buildErrorResponse(req.id, err));

package/src/ipc/cli-client.ts

@@ -60,9 +60,8 @@ export interface CliIpcCallResult<T = unknown> {
   errorDetails?: unknown;
   /**
    * Set when the call was abandoned because `timeoutMs` elapsed with no
-   * response. Distinct from every other `ok: false` shape: the request WAS
-   * delivered and the daemon may still be executing it — closing the client
-   * socket does not abort the handler. Callers that would otherwise retry a
+   * response. The request was delivered and may still be executing unless
+   * `cancelOnDisconnect` was requested. Callers that would otherwise retry a
    * transport failure must not retry this one until the original can no
    * longer be in flight.
    */
@@ -79,7 +78,11 @@ export interface CliIpcCallResult<T = unknown> {
 export async function cliIpcCall<T = unknown>(
   method: string,
   params?: Record<string, unknown>,
-  options?: { timeoutMs?: number; signal?: AbortSignal },
+  options?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    cancelOnDisconnect?: boolean;
+  },
 ): Promise<CliIpcCallResult<T>> {
   if (options?.signal?.aborted) {
     throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
@@ -180,7 +183,12 @@ export async function cliIpcCall<T = unknown>(
 
     socket.on("connect", () => {
       clearTimeout(connectTimer);
-      writeMessage(socket, { id: reqId, method, params });
+      writeMessage(socket, {
+        id: reqId,
+        method,
+        params,
+        ...(opts?.cancelOnDisconnect ? { cancelOnDisconnect: true } : {}),
+      });
 
       callTimer = setTimeout(() => {
         log.debug(

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -980,3 +980,146 @@ describe("LiveVoiceSession room reveal", () => {
     expect(ttsTexts.join(" ")).not.toContain("ASK_GUARDIAN_APPROVAL");
   });
 });
+
+describe("LiveVoiceSession spoken session controls", () => {
+  function createControlsHarness(
+    sessionControls?: LiveVoiceClientStartFrame["sessionControls"],
+  ) {
+    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const harness = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+      startFrame: {
+        ...START_FRAME,
+        ...(sessionControls ? { sessionControls } : {}),
+      },
+    });
+    return { ...harness, getCallbacks, ttsTexts };
+  }
+
+  test("a reply ending with [END_CALL] sends an end control after tts_done", async () => {
+    const { frames, session, getCallbacks, ttsTexts } = createControlsHarness([
+      "end",
+      "mute",
+    ]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Okay, talk soon. [END_CALL]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "session_control"),
+    );
+
+    const ttsDoneIndex = frames.findIndex((frame) => frame.type === "tts_done");
+    const controlIndex = frames.findIndex(
+      (frame) => frame.type === "session_control",
+    );
+    // The goodbye is heard before the call ends.
+    expect(controlIndex).toBeGreaterThan(ttsDoneIndex);
+    expect(frames[controlIndex]).toMatchObject({
+      type: "session_control",
+      turnId: "live-turn-1",
+      action: "end",
+    });
+    expect(assistantDeltaTexts(frames).join("").trim()).toBe(
+      "Okay, talk soon.",
+    );
+    expect(ttsTexts.join(" ")).not.toContain("[END_CALL]");
+  });
+
+  test("a timed mute carries its duration", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["mute"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Muting you for thirty seconds. [MUTE:30]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "session_control"),
+    );
+
+    expect(
+      frames.find((frame) => frame.type === "session_control"),
+    ).toMatchObject({ action: "mute", durationMs: 30_000 });
+  });
+
+  test("a declared look sends its look control after the acknowledgement", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness([
+      "look_screen",
+    ]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(
+      getCallbacks,
+      "Taking a look. What should I focus on? [LOOK:SCREEN]",
+    );
+    emitMessageComplete(getCallbacks);
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "session_control"),
+    );
+
+    expect(
+      frames.find((frame) => frame.type === "session_control"),
+    ).toMatchObject({ action: "look_screen" });
+    // The marker is control, never caption text.
+    expect(assistantDeltaTexts(frames).join("").includes("[LOOK")).toBe(false);
+  });
+
+  test("a control the client did not declare is never sent", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["mute"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Bye. [END_CALL]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+    await flushAsyncCallbacks();
+
+    expect(frames.some((frame) => frame.type === "session_control")).toBe(
+      false,
+    );
+  });
+
+  test("a marker mid-reply controls nothing", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["end"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Say [END_CALL] and I would hang up, but no.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+    await flushAsyncCallbacks();
+
+    expect(frames.some((frame) => frame.type === "session_control")).toBe(
+      false,
+    );
+  });
+
+  // Talking over "okay, bye" means they are not leaving.
+  test("an interrupted goodbye does not end the call", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["end"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Okay, talk soon. [END_CALL]");
+    await flushAsyncCallbacks();
+    await session.handleClientFrame({ type: "interrupt" });
+    emitMessageComplete(getCallbacks);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(frames.some((frame) => frame.type === "session_control")).toBe(
+      false,
+    );
+  });
+
+  test("the prompt teaches only the declared controls", async () => {
+    const { session, getCallbacks, startVoiceTurn } = createControlsHarness([
+      "mute",
+    ]);
+
+    await startReleasedTurn(session, getCallbacks);
+    const prompt =
+      (startVoiceTurn as ReturnType<typeof mock>).mock.calls[0]?.[0]
+        ?.voiceControlPrompt ?? "";
+
+    expect(prompt).toContain("[MUTE]");
+    expect(prompt).not.toContain("[END_CALL]");
+  });
+});

package/src/live-voice/__tests__/live-voice-events.test.ts

@@ -253,14 +253,16 @@ describe("LiveVoiceSession archive and metrics events", () => {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
       // Pins the full production control prompt for the FRONT-DOOR leg (the
-      // first leg of every routed turn): the speech-first rule, and nothing
-      // else. This leg is toolless, so both the screen-reveal and setup-flow
-      // teachings are deliberately absent. It has nothing to show and no
-      // connection to run, and its capability digest already routes anything
-      // needing a tool to the escalated leg (see
-      // live-voice-triage-escalate.test.ts).
+      // first leg of every routed turn): the speech-first rule and the session
+      // controls, and nothing else. This leg is toolless, so both the
+      // screen-reveal and setup-flow teachings are deliberately absent. It
+      // has nothing to show and no connection to run, and its capability
+      // digest already routes anything needing a tool to the escalated leg
+      // (see live-voice-triage-escalate.test.ts). The start frame declares no
+      // client controls, so only the session's own update cadence and the
+      // no-looks line are taught.
       voiceControlPrompt:
-        "You are speaking in a local live voice session. Keep each reply to one to three spoken sentences. The caller is listening, not reading: lead with the answer, say it in the fewest words that are still complete, and stop. No preamble, no recap of the question, no closing offer of more. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links), bulleted or numbered lists, or emojis. Write plain conversational text only; if something is naturally a list, say it as one sentence. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. ",
+        'You are speaking in a local live voice session. Keep each reply to one to three spoken sentences. The caller is listening, not reading: lead with the answer, say it in the fewest words that are still complete, and stop. No preamble, no recap of the question, no closing offer of more. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links), bulleted or numbered lists, or emojis. Write plain conversational text only; if something is naturally a list, say it as one sentence. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work, or a card with an image or a link instead of reading an address out); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. The user can also control this call by asking you. Only when they clearly ask:\n- This call cannot turn on a screen share or the camera. If they ask you to look at their screen or at something and you have no other way to see it, say so briefly instead of pretending to look.\n- To hear fewer spoken progress updates while you work (for example "don\'t give me updates so often"), confirm that you will only check in now and then and will tell them when it is done, then end your reply with [UPDATES:FEWER]. If they later want regular updates back, confirm and end with [UPDATES:NORMAL].\nThe marker must be the very last thing in your reply. It is never spoken and does nothing anywhere else.',
     });
     callbacks?.assistant_text_delta?.(makeTextDelta("Hello there."));
     callbacks?.message_complete?.(makeMessageComplete());

package/src/live-voice/__tests__/live-voice-progress.test.ts

@@ -927,3 +927,82 @@ describe("LiveVoiceSession progress narration", () => {
     emitMessageComplete(getCallbacks);
   });
 });
+
+describe("LiveVoiceSession spoken update cadence", () => {
+  async function runTurnAskingFor(
+    session: LiveVoiceSession,
+    getCallbacks: () => VoiceTurnCallbacks | undefined,
+    frames: { type: string }[],
+    reply: string,
+  ): Promise<void> {
+    emitTextDelta(getCallbacks, reply);
+    emitMessageComplete(getCallbacks);
+    await waitFor(
+      () => frames.some((frame) => frame.type === "tts_done"),
+      "first turn never finished",
+    );
+    // Let the post-turn re-arm run before releasing the next turn.
+    await sleep(20);
+    const previous = getCallbacks();
+    // Typed, because a manual session's microphone re-arm is not what this
+    // exercises: the cadence is the session's, however the next turn arrives.
+    await session.handleClientFrame({ type: "text", text: "go ahead" });
+    await waitFor(() => getCallbacks() !== previous, "next turn never started");
+  }
+
+  test("after the user asks for fewer updates, tool activity no longer narrates", async () => {
+    const generateProgressText = mock(async () => GENERATED_NARRATION);
+    const { frames, session, getCallbacks, ttsTexts } = createProgressHarness({
+      frontModelConfig: progressConfig({ opsThreshold: 3, minGapMs: 10 }),
+      progressNarrator: makeProgressNarrator(generateProgressText),
+    });
+
+    await startReleasedTurn(session, getCallbacks);
+    await runTurnAskingFor(
+      session,
+      getCallbacks,
+      frames,
+      "Sure, I'll only check in now and then. [UPDATES:FEWER]",
+    );
+    emitToolStart(getCallbacks, "web_search", "tool-1");
+    emitToolResult(getCallbacks, "web_search", "tool-1");
+    emitToolStart(getCallbacks, "file_read", "tool-2");
+    emitToolResult(getCallbacks, "file_read", "tool-2");
+    emitToolStart(getCallbacks, "web_search", "tool-3");
+    await sleep(40);
+
+    expect(generateProgressText).not.toHaveBeenCalled();
+    expect(ttsTexts.join(" ")).not.toContain("[UPDATES");
+    emitMessageComplete(getCallbacks);
+  });
+
+  test("asking for updates back restores the normal cadence", async () => {
+    const generateProgressText = mock(async () => GENERATED_NARRATION);
+    const { frames, session, getCallbacks, ttsTexts } = createProgressHarness({
+      frontModelConfig: progressConfig({ opsThreshold: 3, minGapMs: 10 }),
+      progressNarrator: makeProgressNarrator(generateProgressText),
+    });
+
+    await startReleasedTurn(session, getCallbacks);
+    await runTurnAskingFor(
+      session,
+      getCallbacks,
+      frames,
+      "Okay, fewer updates. [UPDATES:FEWER]",
+    );
+    frames.length = 0;
+    await runTurnAskingFor(
+      session,
+      getCallbacks,
+      frames,
+      "Got it, I'll keep you posted. [UPDATES:NORMAL]",
+    );
+    emitToolStart(getCallbacks, "web_search", "tool-1");
+    emitToolStart(getCallbacks, "file_read", "tool-2");
+    emitToolStart(getCallbacks, "web_search", "tool-3");
+    await waitFor(() => ttsTexts.includes(GENERATED_NARRATION));
+
+    expect(generateProgressText).toHaveBeenCalledTimes(1);
+    emitMessageComplete(getCallbacks);
+  });
+});

package/src/live-voice/__tests__/live-voice-session-telemetry.test.ts

@@ -350,6 +350,25 @@ describe("live-voice turn attribution", () => {
     expect(options.assistantMessageInterface).toBe("macos");
   });
 
+  test("a session opened from the macOS desktop client asks for the desktop skills", async () => {
+    const options = await captureTurnOptions({
+      ...START_FRAME,
+      client: "macos",
+    });
+
+    expect(options.macosDesktopSession).toBe(true);
+  });
+
+  test("a session from any other client does not ask for the desktop skills", async () => {
+    for (const startFrame of [{ ...START_FRAME, client: "ios" }, START_FRAME]) {
+      const options = await captureTurnOptions(
+        startFrame as LiveVoiceClientStartFrame,
+      );
+
+      expect(options.macosDesktopSession).toBeUndefined();
+    }
+  });
+
   test("omits the client when the start frame declares none", async () => {
     const options = await captureTurnOptions(START_FRAME);