@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/live-voice/__tests__/activity-label.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Tests for the voice activity line.
+ *
+ * The invariant worth guarding is totality: the tool vocabulary is open
+ * (plugins, MCP servers, and skills all contribute names this module has never
+ * seen), and the surface this feeds is a Lock Screen the user cannot correct.
+ * A label that came back empty would blank the island exactly when the
+ * assistant is busiest.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  activityLabelForTool,
+  approvalActivityLabel,
+  GENERIC_ACTIVITY_LABEL,
+} from "../activity-label.js";
+
+describe("activityLabelForTool", () => {
+  test("names what the user would say is happening, not the tool", () => {
+    expect(activityLabelForTool("bash")).toBe("Running a command");
+    expect(activityLabelForTool("web_search")).toBe("Searching the web");
+    expect(activityLabelForTool("file_read")).toBe("Reading a file");
+  });
+
+  // Where a tool runs is not a distinction anyone glancing at a Lock Screen is
+  // making.
+  test("host and sandbox variants read the same", () => {
+    expect(activityLabelForTool("host_bash")).toBe(
+      activityLabelForTool("bash"),
+    );
+    expect(activityLabelForTool("host_file_read")).toBe(
+      activityLabelForTool("file_read"),
+    );
+  });
+
+  test("falls back by prefix for structured tool families", () => {
+    expect(activityLabelForTool("browser_click")).toBe("Using the browser");
+    expect(activityLabelForTool("mcp_notion_search")).toBe(
+      "Using a connected app",
+    );
+  });
+
+  test("every tool gets a label, including ones this module has never seen", () => {
+    for (const name of [
+      "slack_conversations_history",
+      "",
+      "a",
+      "some_vendor::weird.tool/name",
+    ]) {
+      expect(activityLabelForTool(name)).toBe(GENERIC_ACTIVITY_LABEL);
+    }
+  });
+
+  test("labels stay short enough for the slot they land in", () => {
+    for (const name of [
+      "bash",
+      "web_search",
+      "host_file_transfer",
+      "computer_use",
+      "ui_show",
+      "unknown_tool",
+    ]) {
+      const label = activityLabelForTool(name);
+      expect(label.length).toBeLessThanOrEqual(32);
+      expect(label).not.toMatch(/[.!?]$/);
+    }
+  });
+});
+
+describe("approvalActivityLabel", () => {
+  // The turn is not running the tool, it is waiting to be allowed to. Saying
+  // the former is the misstatement this exists to stop — and the line has to
+  // name *something*, or the island asks the user to approve a blank.
+  test("keeps the tool's phrase and says who is being waited on", () => {
+    expect(approvalActivityLabel("bash")).toBe(
+      "Running a command — needs your okay",
+    );
+    expect(approvalActivityLabel("web_search")).toBe(
+      "Searching the web — needs your okay",
+    );
+  });
+
+  test("an unrecognized tool still reads as a wait", () => {
+    expect(approvalActivityLabel("some_vendor_tool")).toBe(
+      `${GENERIC_ACTIVITY_LABEL} — needs your okay`,
+    );
+  });
+
+  // A confirmation from a proxy or network prompter has no tool behind it, and
+  // "Working on it — needs your okay" would claim work that is not happening.
+  test("drops the phrase entirely when there is no tool to name", () => {
+    expect(approvalActivityLabel("")).toBe("Needs your okay");
+  });
+});

package/src/live-voice/__tests__/live-activity-reporter.test.ts

@@ -34,16 +34,26 @@ function sttFinal(text: string): LiveVoiceServerFramePayload {
 
 /** A reporter whose dispatches are captured instead of sent. */
 class RecordingReporter extends LiveActivityReporter {
-  readonly dispatched: Array<{ phase: string; event: string }> = [];
+  readonly dispatched: Array<{ phase: string; event: string; detail: string }> =
+    [];
 
   protected override async dispatch(
     phase: string,
     event: "update" | "end",
+    detail: string,
   ): Promise<void> {
-    this.dispatched.push({ phase, event });
+    this.dispatched.push({ phase, event, detail });
   }
 }
 
+function activity(label: string): LiveVoiceServerFramePayload {
+  return {
+    type: "activity",
+    turnId: "t1",
+    label,
+  } as LiveVoiceServerFramePayload;
+}
+
 describe("phaseForFrame", () => {
   test("maps the frames the client derives phases from", () => {
     expect(phaseForFrame(frame("utterance_end"), "listening")).toBe(
@@ -92,7 +102,7 @@ describe("LiveActivityReporter", () => {
     reporter.report(frame("thinking"));
 
     expect(reporter.dispatched).toEqual([
-      { phase: "thinking", event: "update" },
+      { phase: "thinking", event: "update", detail: "" },
     ]);
   });
 
@@ -105,7 +115,7 @@ describe("LiveActivityReporter", () => {
     reporter.report(frame("tts_audio"));
 
     expect(reporter.dispatched).toEqual([
-      { phase: "speaking", event: "update" },
+      { phase: "speaking", event: "update", detail: "" },
     ]);
   });
 
@@ -144,6 +154,7 @@ describe("LiveActivityReporter", () => {
     expect(reporter.dispatched.at(-1)).toEqual({
       phase: "ending",
       event: "end",
+      detail: "",
     });
   });
 
@@ -165,7 +176,77 @@ describe("LiveActivityReporter", () => {
     reporter.end();
     reporter.report(frame("tts_audio"));
 
-    expect(reporter.dispatched).toEqual([{ phase: "ending", event: "end" }]);
+    expect(reporter.dispatched).toEqual([
+      { phase: "ending", event: "end", detail: "" },
+    ]);
+  });
+});
+
+describe("LiveActivityReporter activity line", () => {
+  test("carries the activity label alongside the phase it holds", () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(frame("utterance_end"));
+    reporter.report(frame("thinking"));
+    reporter.report(activity("Running a command"));
+
+    expect(reporter.dispatched.at(-1)).toEqual({
+      phase: "thinking",
+      event: "update",
+      detail: "Running a command",
+    });
+  });
+
+  // A push replaces the whole content state, so the label has to ride along on
+  // phase changes too, or the next phase would blank it.
+  test("keeps the label through a later phase change", () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(frame("thinking"));
+    reporter.report(activity("Reading a file"));
+    reporter.report(frame("tts_audio"));
+
+    expect(reporter.dispatched.at(-1)).toEqual({
+      phase: "speaking",
+      event: "update",
+      detail: "Reading a file",
+    });
+  });
+
+  test("an empty label clears the line", () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(frame("thinking"));
+    reporter.report(activity("Reading a file"));
+    reporter.report(activity(""));
+
+    expect(reporter.dispatched.at(-1)?.detail).toBe("");
+  });
+
+  test("does not dispatch a label it already sent", () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(frame("thinking"));
+    reporter.report(activity("Reading a file"));
+    const before = reporter.dispatched.length;
+    reporter.report(activity("Reading a file"));
+
+    expect(reporter.dispatched.length).toBe(before);
+  });
+
+  // A tool can start before any phase-bearing frame lands. There is no content
+  // state to attach a label to yet, and the phase that follows carries it.
+  test("holds a label that arrives before any phase", () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(activity("Searching the web"));
+    expect(reporter.dispatched).toEqual([]);
+
+    reporter.report(frame("thinking"));
+
+    expect(reporter.dispatched).toEqual([
+      { phase: "thinking", event: "update", detail: "Searching the web" },
+    ]);
   });
 });
 

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

@@ -154,16 +154,42 @@ async function waitFor(
   throw new Error(message);
 }
 
+/**
+ * The most recent `activity` frame, or `undefined` when none has been sent.
+ * `findLast` is past this project's lib target, so the filter-and-take-last
+ * form stands in for it.
+ */
+function lastActivityFrame(
+  frames: LiveVoiceServerFrame[],
+): Extract<LiveVoiceServerFrame, { type: "activity" }> | undefined {
+  const activity = frames.filter(
+    (frame): frame is Extract<LiveVoiceServerFrame, { type: "activity" }> =>
+      frame.type === "activity",
+  );
+  return activity[activity.length - 1];
+}
+
 function createCapturingTurnStarter(): {
   startVoiceTurn: LiveVoiceTurnStarter;
   getCallbacks: () => VoiceTurnCallbacks | undefined;
+  announceApprovalPending: () => void;
+  announceApprovalsResolved: () => void;
 } {
   let callbacks: VoiceTurnCallbacks | undefined;
+  let onApprovalPending: ((requestId: string) => void) | undefined;
+  let onApprovalsResolved: (() => void) | undefined;
   const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
     callbacks = options.callbacks;
+    onApprovalPending = options.onApprovalPending;
+    onApprovalsResolved = options.onApprovalsResolved;
     return { turnId: "bridge-turn-1", abort: mock() };
   });
-  return { startVoiceTurn, getCallbacks: () => callbacks };
+  return {
+    startVoiceTurn,
+    getCallbacks: () => callbacks,
+    announceApprovalPending: () => onApprovalPending?.("req-1"),
+    announceApprovalsResolved: () => onApprovalsResolved?.(),
+  };
 }
 
 function createRecordingTtsStreamer(): {
@@ -442,7 +468,7 @@ describe("LiveVoiceSession assistant turn", () => {
     });
   });
 
-  test("records tool_use_start on the active turn without emitting frames", async () => {
+  test("records tool_use_start on the active turn and publishes what it is doing", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       callbacks = options.callbacks;
@@ -459,9 +485,8 @@ describe("LiveVoiceSession assistant turn", () => {
       "thinking",
     ]);
 
-    const frameCountBefore = frames.length;
     callbacks?.tool_use_start?.("some_tool");
-    await flushAsyncCallbacks();
+    await waitForFrameCount(frames, 4);
 
     const activeTurn = (
       session as unknown as {
@@ -469,20 +494,30 @@ describe("LiveVoiceSession assistant turn", () => {
       }
     ).activeAssistantTurn;
     expect(activeTurn?.toolUseStarted).toBe(true);
-    expect(frames).toHaveLength(frameCountBefore);
+    // One activity frame, so a silent stretch of tool work is visible on the
+    // surfaces that show the session. An unrecognized tool still gets a line.
+    expect(frames.at(-1)).toMatchObject({
+      type: "activity",
+      label: "Working on it",
+    });
 
     callbacks?.message_complete?.({
       type: "message_complete",
       conversationId: "conversation-123",
       messageId: "assistant-message-123",
     });
-    await waitForFrameCount(frames, 4);
+    await waitForFrameCount(frames, 6);
     expect(frames.map((frame) => frame.type)).toEqual([
       "ready",
       "stt_final",
       "thinking",
+      "activity",
       "tts_done",
+      // The turn is over, so the line clears: no surface should keep showing
+      // the last tool it touched through the silence that follows.
+      "activity",
     ]);
+    expect(frames.at(-1)).toMatchObject({ type: "activity", label: "" });
   });
 
   test("interrupt aborts the in-flight turn and ignores late bridge events", async () => {
@@ -609,7 +644,7 @@ describe("LiveVoiceSession tool-use spoken ack", () => {
   });
 });
 
-describe("LiveVoiceSession minimize-room marker", () => {
+describe("LiveVoiceSession room reveal", () => {
   function createMarkerHarness() {
     const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
     const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
@@ -624,11 +659,10 @@ describe("LiveVoiceSession minimize-room marker", () => {
   }
 
   /**
-   * Marker-command harness for the leg that can actually put something on
-   * screen: routing fronts every turn with the fast leg, so the front-door
-   * call is scripted to escalate ("[1] Working on it.") and the returned
-   * callbacks drive the ESCALATED leg — the only leg whose completion may
-   * latch `minimizeRequested`.
+   * Harness for the leg that can actually put something on screen: routing
+   * fronts every turn with the fast leg, so the front-door call is scripted to
+   * escalate ("[1] Working on it.") and the returned callbacks drive the
+   * ESCALATED leg; the toolless front door can never run a ui tool.
    */
   function createEscalatedMarkerHarness() {
     let escalatedCallbacks: VoiceTurnCallbacks | undefined;
@@ -664,35 +698,285 @@ describe("LiveVoiceSession minimize-room marker", () => {
     };
   }
 
-  test("strips a terminal [-1] from deltas and TTS and emits minimize_room after tts_done", async () => {
-    const { frames, session, getCallbacks, ttsTexts } =
-      createEscalatedMarkerHarness();
+  /** Run a ui tool to completion, as the agent loop would. */
+  function runUiTool(
+    getCallbacks: () => VoiceTurnCallbacks | undefined,
+    toolName: string,
+    opts?: { isError?: boolean },
+  ): void {
+    getCallbacks()?.tool_use_start?.(toolName);
+    getCallbacks()?.tool_result?.({
+      toolName,
+      resultPreview: "",
+      ...(opts?.isError === true ? { isError: true } : {}),
+    });
+  }
+
+  // Showing a surface is what reveals the screen. Nothing the model says does,
+  // so the user never loses the reveal to a forgotten token.
+  test("a ui tool emits minimize_room after tts_done", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
 
     await startReleasedTurn(session, getCallbacks);
-    emitTextDelta(getCallbacks, "hello world. [-1]");
+    runUiTool(getCallbacks, "ui_show");
+    emitTextDelta(getCallbacks, "Here is the summary.");
     emitMessageComplete(getCallbacks);
     await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
 
-    const joined = assistantDeltaTexts(frames).join("");
-    expect(joined).toContain("hello world. ");
-    expect(joined).not.toContain("[-1]");
-    expect(ttsTexts.join(" ")).not.toContain("[-1]");
     const ttsDoneIndex = frames.findIndex((frame) => frame.type === "tts_done");
     const minimizeIndex = frames.findIndex(
       (frame) => frame.type === "minimize_room",
     );
     expect(ttsDoneIndex).toBeGreaterThanOrEqual(0);
+    // After the speech drains, never mid-sentence.
     expect(minimizeIndex).toBeGreaterThan(ttsDoneIndex);
     expect(frames[minimizeIndex]).toMatchObject({
       type: "minimize_room",
       turnId: "live-turn-1",
     });
+    // At most once, however many surfaces the turn touched.
     expect(
       frames.filter((frame) => frame.type === "minimize_room"),
     ).toHaveLength(1);
   });
 
-  test("holds a marker split across deltas, never leaks the partial, and still emits", async () => {
+  // The reveal follows the surface, not the attempt: a rejected call (no
+  // surface_type, an empty card, a client that never acks) rendered nothing,
+  // and minimizing to show nothing is worse than staying put.
+  test("a failed ui call reveals nothing", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    runUiTool(getCallbacks, "ui_show", { isError: true });
+    emitTextDelta(getCallbacks, "I could not show that.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("a surface taken away before the reply ends reveals nothing", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    runUiTool(getCallbacks, "ui_show");
+    runUiTool(getCallbacks, "ui_dismiss");
+    emitTextDelta(getCallbacks, "Never mind, sorted it.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  // Opening an app puts something on screen just as a card does; a list keyed
+  // on "ui_" would have missed it.
+  test("opening an app reveals the screen", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    runUiTool(getCallbacks, "app_open");
+    emitTextDelta(getCallbacks, "Opened it up.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
+
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(true);
+  });
+
+  // A blocked turn has no speech left to drain, and the card it is blocked on
+  // renders behind the room. Waiting for a drain that is not coming would
+  // leave the call silent in front of a decision the user cannot see.
+  test("a pending approval reveals the screen immediately", async () => {
+    const { startVoiceTurn, announceApprovalPending } =
+      createCapturingTurnStarter();
+    const { frames, session } = createSessionHarness({ startVoiceTurn });
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    announceApprovalPending();
+    await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
+
+    // Before any tts_done, unlike the drain-scoped reveal a shown surface gets.
+    expect(frames.some((frame) => frame.type === "tts_done")).toBe(false);
+  });
+
+  // Every phrase progress narration has describes work in flight ("still on
+  // it", "almost there"). While the turn is blocked on the user, all of them
+  // are false, and the one that matters is the one about who is being waited
+  // on.
+  test("says it is waiting, once, and stops narrating progress", async () => {
+    const {
+      startVoiceTurn,
+      announceApprovalPending,
+      announceApprovalsResolved,
+    } = createCapturingTurnStarter();
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    announceApprovalPending();
+    await waitFor(() => ttsTexts.join(" ").includes("okay"));
+    // Repeat announcements do not repeat the line.
+    announceApprovalPending();
+    await flushAsyncCallbacks();
+
+    const saidWaiting = ttsTexts.filter((text) => text.includes("okay")).length;
+    expect(saidWaiting).toBe(1);
+
+    announceApprovalsResolved();
+    await flushAsyncCallbacks();
+  });
+
+  // `tool_use_start` fires before the approval gate blocks, so without this the
+  // island keeps saying "Running a command" for the whole wait — a claim about
+  // work in flight made at the one moment nothing is in flight. The request id
+  // is what turns that line from accurate into answerable: it is what the Live
+  // Activity's Approve and Deny send back.
+  test("a pending approval publishes an answerable activity line", async () => {
+    const { startVoiceTurn, getCallbacks, announceApprovalPending } =
+      createCapturingTurnStarter();
+    const { frames, session } = createSessionHarness({ startVoiceTurn });
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    getCallbacks()?.tool_use_start?.("bash");
+    await waitFor(() =>
+      frames.some(
+        (frame) => frame.type === "activity" && frame.label.length > 0,
+      ),
+    );
+    announceApprovalPending();
+    await waitFor(() =>
+      frames.some(
+        (frame) =>
+          frame.type === "activity" && frame.approvalRequestId === "req-1",
+      ),
+    );
+
+    const waiting = lastActivityFrame(frames);
+    // The tool's own phrase, kept, plus who is being waited on — so the line
+    // beside the buttons names what is being approved without naming the tool
+    // or its arguments to a Lock Screen.
+    expect(waiting).toMatchObject({
+      label: "Running a command — needs your okay",
+      approvalRequestId: "req-1",
+    });
+  });
+
+  // However the decision is made — the card in the app, the daemon's own
+  // timeout, a superseding message — the buttons must go with it. They are
+  // rendered from the id, so retiring the id is what retires them.
+  test("resolving the approval retires the request id", async () => {
+    const {
+      startVoiceTurn,
+      getCallbacks,
+      announceApprovalPending,
+      announceApprovalsResolved,
+    } = createCapturingTurnStarter();
+    const { frames, session } = createSessionHarness({ startVoiceTurn });
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    getCallbacks()?.tool_use_start?.("bash");
+    announceApprovalPending();
+    await waitFor(() =>
+      frames.some(
+        (frame) =>
+          frame.type === "activity" && frame.approvalRequestId === "req-1",
+      ),
+    );
+
+    announceApprovalsResolved();
+    await waitFor(
+      () => lastActivityFrame(frames)?.approvalRequestId === undefined,
+    );
+
+    const resumed = lastActivityFrame(frames);
+    // Back to the tool that is now genuinely running, with nothing to answer.
+    expect(resumed).toMatchObject({ label: "Running a command" });
+    expect(resumed?.approvalRequestId).toBeUndefined();
+  });
+
+  // A turn can start and finish other work while it is blocked. Each of those
+  // events republishes the activity line, and a republish composed as if
+  // nothing were pending would take the request id down with it — retiring the
+  // island's buttons while the turn was still waiting on them.
+  test("a parallel tool event mid-wait does not retire the buttons", async () => {
+    const { startVoiceTurn, getCallbacks, announceApprovalPending } =
+      createCapturingTurnStarter();
+    const { frames, session } = createSessionHarness({ startVoiceTurn });
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    getCallbacks()?.tool_use_start?.("bash");
+    announceApprovalPending();
+    await waitFor(() =>
+      frames.some(
+        (frame) =>
+          frame.type === "activity" && frame.approvalRequestId === "req-1",
+      ),
+    );
+
+    getCallbacks()?.tool_use_start?.("web_search");
+    getCallbacks()?.tool_result?.({
+      toolName: "web_search",
+      resultPreview: "",
+    });
+    await flushAsyncCallbacks();
+
+    const latest = lastActivityFrame(frames);
+    expect(latest?.approvalRequestId).toBe("req-1");
+    // And still naming the tool the decision is about, not the one that ran
+    // alongside it.
+    expect(latest?.label).toBe("Running a command — needs your okay");
+  });
+
+  test("dismissing a surface does not reveal the screen", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    runUiTool(getCallbacks, "ui_dismiss");
+    emitTextDelta(getCallbacks, "Cleared that away.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    // Minimizing to show the user something that is no longer there is the
+    // opposite of the point.
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  // The marker is no longer taught to any leg, so this is about a model that
+  // emits one anyway: it must not be spoken, and it must not move the room.
+  test("a terminal [-1] is stripped from deltas and TTS and reveals nothing", async () => {
+    const { frames, session, getCallbacks, ttsTexts } =
+      createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "hello world. [-1]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    const joined = assistantDeltaTexts(frames).join("");
+    expect(joined).toContain("hello world. ");
+    expect(joined).not.toContain("[-1]");
+    expect(ttsTexts.join(" ")).not.toContain("[-1]");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("holds a marker split across deltas and never leaks the partial", async () => {
     const { frames, session, getCallbacks, ttsTexts } =
       createEscalatedMarkerHarness();
 
@@ -703,14 +987,14 @@ describe("LiveVoiceSession minimize-room marker", () => {
 
     emitTextDelta(getCallbacks, "1]");
     emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
 
     const joined = assistantDeltaTexts(frames).join("");
     expect(joined).not.toContain("[-");
     expect(ttsTexts.join(" ")).not.toContain("[-");
   });
 
-  test("a mid-reply [-1] (content, not command) is stripped from speech but never minimizes", async () => {
+  test("a mid-reply [-1] is stripped from speech and never minimizes", async () => {
     const { frames, session, getCallbacks } = createMarkerHarness();
 
     await startReleasedTurn(session, getCallbacks);
@@ -728,7 +1012,8 @@ describe("LiveVoiceSession minimize-room marker", () => {
     const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
 
     await startReleasedTurn(session, getCallbacks);
-    emitTextDelta(getCallbacks, "Minimizing now. [-1]");
+    runUiTool(getCallbacks, "ui_show");
+    emitTextDelta(getCallbacks, "Showing you now.");
     await flushAsyncCallbacks();
 
     await session.handleClientFrame({ type: "interrupt" });
@@ -738,7 +1023,7 @@ describe("LiveVoiceSession minimize-room marker", () => {
     expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
   });
 
-  test("a turn without the marker emits no minimize_room frame", async () => {
+  test("a turn that shows nothing emits no minimize_room frame", async () => {
     const { frames, session, getCallbacks } = createMarkerHarness();
 
     await startReleasedTurn(session, getCallbacks);