@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -33,7 +33,7 @@ mock.module("../../daemon/conversation-store.js", () => ({
 
 // Conversation-CRUD doubles for the teardown transcript-hygiene pass. The
 // real module is spread so every other export keeps its production behavior;
-// only the three functions the hygiene pass (and discard) touch are recorded.
+// only the functions the hygiene pass (and discard) touch are recorded.
 import * as realConversationCrud from "../../persistence/conversation-crud.js";
 
 let getMessageByIdImpl: (
@@ -65,10 +65,14 @@ mock.module("../../persistence/conversation-crud.js", () => ({
     crudLog.deletes.push(messageId);
     return { segmentIds: [], deletedSummaryIds: [] };
   },
+  // The echo path advances the snapshot anchor for a real-user turn; the
+  // fake conversation has no row in SQLite, so stub the write out.
+  recordConversationPersistedSeq: () => {},
 }));
 
 import { setConfig } from "../../__tests__/helpers/set-config.js";
 import { ABORT_WATCHDOG_MS } from "../../daemon/abort-watchdog.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { CALL_OPENING_MARKER } from "../voice-control-protocol.js";
 import {
   cutFrontDoorContentAtVerdict,
@@ -347,6 +351,67 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
   });
 });
 
+describe("startVoiceTurn hiddenSyntheticPrompt", () => {
+  // A caller whose internal instruction is composed per call carries no
+  // sentinel for the content comparisons to recognize, so it declares itself.
+  const SYNTHETIC_CONTENT =
+    "(the background task finished — announce the result)";
+
+  /** The `user_message_echo` events `turn` publishes to hub subscribers. */
+  async function collectUserMessageEchoes(
+    turn: () => Promise<unknown>,
+  ): Promise<Array<{ type: string }>> {
+    const published: Array<{ type: string }> = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      filter: { conversationId: "conv-voice-bridge-test" },
+      callback: (event) => {
+        published.push(event.message);
+      },
+    });
+    try {
+      await turn();
+    } finally {
+      subscription.dispose();
+    }
+    return published.filter((msg) => msg.type === "user_message_echo");
+  }
+
+  test("a declared prompt persists hidden and suppresses its echo", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    const echoes = await collectUserMessageEchoes(() =>
+      startVoiceTurn({
+        ...makeTurnOptions(),
+        content: SYNTHETIC_CONTENT,
+        hiddenSyntheticPrompt: true,
+      }),
+    );
+
+    expect(fake.lastPersistOpts()?.content).toBe(SYNTHETIC_CONTENT);
+    expect(fake.lastPersistOpts()?.metadata).toEqual({ hidden: true });
+    expect(echoes).toHaveLength(0);
+  });
+
+  test("the same content without the flag stays a plain user turn", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    const echoes = await collectUserMessageEchoes(() =>
+      startVoiceTurn({
+        ...makeTurnOptions(),
+        content: SYNTHETIC_CONTENT,
+      }),
+    );
+
+    expect(fake.lastPersistOpts()?.metadata).toBeUndefined();
+    expect(echoes).toEqual([
+      expect.objectContaining({ text: SYNTHETIC_CONTENT }),
+    ]);
+  });
+});
+
 describe("startVoiceTurn triage-and-escalate control prompt", () => {
   // Live-voice supplies its own voiceControlPrompt, bypassing
   // buildVoiceCallControlPrompt where the routing-leg rule is normally injected.
@@ -1101,7 +1166,7 @@ describe("startVoiceTurn tool-event forwarding", () => {
     fakeConversation = fake.conversation;
   }
 
-  test("tool_use_start delivers the tool name and toolUseId", async () => {
+  test("tool_use_start delivers the tool name, toolUseId, and input", async () => {
     makeEventEmittingConversation([
       {
         type: "tool_use_start",
@@ -1121,7 +1186,10 @@ describe("startVoiceTurn tool-event forwarding", () => {
     await flushMicrotasks();
 
     expect(starts).toEqual([
-      { toolName: "web_search", detail: { toolUseId: "toolu-1" } },
+      {
+        toolName: "web_search",
+        detail: { toolUseId: "toolu-1", input: { query: "weather" } },
+      },
     ]);
   });
 
@@ -1325,7 +1393,7 @@ describe("cutFrontDoorContentAtVerdict", () => {
   });
 });
 
-describe("front-door transcript hygiene (teardown pass)", () => {
+describe("transcript hygiene (teardown pass)", () => {
   beforeEach(resetCrudLog);
 
   function makeRow(text: string) {
@@ -1415,16 +1483,170 @@ describe("front-door transcript hygiene (teardown pass)", () => {
     expect(events).not.toContain("loadFromDb");
   });
 
-  test("a non-routed leg never runs the hygiene pass", async () => {
-    makeReservedRowConversation();
+  test("a front-door answer ending with the minimize marker has the marker stripped", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => makeRow("Here we go, watch the overlay. [-1]");
+
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toEqual([
+      {
+        messageId: "assistant-row-1",
+        content: JSON.stringify([
+          { type: "text", text: "Here we go, watch the overlay." },
+        ]),
+      },
+    ]);
+    expect(crudLog.deletes).toHaveLength(0);
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a marker-only front-door answer row is deleted", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => makeRow("[-1]");
+
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toHaveLength(0);
+    expect(crudLog.deletes).toEqual(["assistant-row-1"]);
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a non-routed leg leaves verdict-token content untouched (verdict cutting is front-door-only)", async () => {
+    const { events } = makeReservedRowConversation();
     getMessageByIdImpl = () => makeRow("[1] Anything at all");
 
     await startVoiceTurn(makeTurnOptions());
     await flushMicrotasks();
 
-    expect(crudLog.reads).toHaveLength(0);
+    expect(crudLog.reads).toEqual(["assistant-row-1"]);
+    expect(crudLog.updates).toHaveLength(0);
+    expect(crudLog.deletes).toHaveLength(0);
+    expect(events).not.toContain("loadFromDb");
+  });
+
+  test("a main-leg row containing the minimize marker persists with the marker stripped", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => makeRow("Done, take a look [-1]");
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toEqual([
+      {
+        messageId: "assistant-row-1",
+        content: JSON.stringify([{ type: "text", text: "Done, take a look" }]),
+      },
+    ]);
+    expect(crudLog.deletes).toHaveLength(0);
+    // The clean row must reach in-memory history and sync consumers.
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a mid-text [-1] (content, not command) leaves the row untouched", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () =>
+      makeRow("The array [-1] sorts first, then the rest.");
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toHaveLength(0);
+    expect(crudLog.deletes).toHaveLength(0);
+    expect(events).not.toContain("loadFromDb");
+  });
+
+  test("a marker-only main-leg row is deleted, not persisted as an empty bubble", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => makeRow("[-1]");
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
     expect(crudLog.updates).toHaveLength(0);
+    expect(crudLog.deletes).toEqual(["assistant-row-1"]);
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a terminal marker split across text blocks is stripped whole", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => ({
+      ...makeRow(""),
+      content: [
+        { type: "text", text: "Done, take a look [-" },
+        { type: "text", text: "1]" },
+      ],
+    });
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toEqual([
+      {
+        messageId: "assistant-row-1",
+        content: JSON.stringify([{ type: "text", text: "Done, take a look" }]),
+      },
+    ]);
     expect(crudLog.deletes).toHaveLength(0);
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a marker-only row split across text blocks is deleted", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => ({
+      ...makeRow(""),
+      content: [
+        { type: "text", text: "[-" },
+        { type: "text", text: "1]" },
+      ],
+    });
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toHaveLength(0);
+    expect(crudLog.deletes).toEqual(["assistant-row-1"]);
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a marker-only row with a surviving non-text block is rewritten, never deleted", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => ({
+      ...makeRow("[-1]"),
+      content: [
+        { type: "text", text: "[-1]" },
+        { type: "tool_use", id: "tool-1", name: "app_create", input: {} },
+      ],
+    });
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
+    expect(crudLog.deletes).toHaveLength(0);
+    expect(crudLog.updates).toEqual([
+      {
+        messageId: "assistant-row-1",
+        content: JSON.stringify([
+          { type: "tool_use", id: "tool-1", name: "app_create", input: {} },
+        ]),
+      },
+    ]);
+    expect(events).toContain("loadFromDb");
+  });
+
+  test("a main-leg row without the minimize marker is never rewritten", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () => makeRow("Done, take a look.");
+
+    await startVoiceTurn(makeTurnOptions());
+    await flushMicrotasks();
+
+    expect(crudLog.reads).toEqual(["assistant-row-1"]);
+    expect(crudLog.updates).toHaveLength(0);
+    expect(crudLog.deletes).toHaveLength(0);
+    expect(events).not.toContain("loadFromDb");
   });
 
   test("a discarded speculative leg deletes its reserved assistant row at teardown", async () => {

package/src/calls/__tests__/voice-triage-escalate.test.ts

@@ -316,10 +316,9 @@ describe("escalation continuation content", () => {
 
 // This module is the surface-agnostic escalation *policy* (profiles, prompt
 // rules, the verdict classifier, the bridge cap/fallback decision). The
-// two-leg *routing* runs on the in-app Voice Mode surface (LiveVoiceSession),
-// gated behind the single voice-mode flag — see
-// live-voice/__tests__/live-voice-triage-escalate.test.ts for the orchestration
-// coverage (flag gating, verdict-first hand-off, token suppression, fallback
+// two-leg *routing* runs on the in-app Voice Mode surface (LiveVoiceSession)
+// — see live-voice/__tests__/live-voice-triage-escalate.test.ts for the
+// orchestration coverage (verdict-first hand-off, token suppression, fallback
 // bridge, barge-in). What remains for the manual cli-testing flow is true
 // end-to-end audio: real TTS timing across the bridge, and the residual
 // broadcast raw-token leak (issue #37850, shared by both voice surfaces) once

package/src/calls/call-controller.ts

@@ -8,6 +8,7 @@
  * barge-in, state machine, guardian verification).
  */
 
+import type { AssistantEvent } from "../api/index.js";
 import { revokeScopedApprovalGrantsForContext } from "../approvals/scoped-approval-grants.js";
 import {
   expireGuardianRequest,
@@ -16,7 +17,6 @@ import {
   getRequestByPendingQuestionOrNull,
   listGuardianRequestDeliveriesOrEmpty,
 } from "../channels/gateway-guardian-requests.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
@@ -166,7 +166,7 @@ export class CallController {
   /** Monotonic run id used to suppress stale turn side effects after interruption. */
   private llmRunVersion = 0;
   /** Optional broadcast function for emitting events to connected clients. */
-  private broadcast?: (msg: ServerMessage) => void;
+  private broadcast?: (msg: AssistantEvent) => void;
   /** Assistant identity for scoping guardian bindings. */
   private assistantId: string;
   /** Guardian trust context for the current caller, when available. */
@@ -195,7 +195,7 @@ export class CallController {
     transport: CallTransport,
     task: string | null,
     opts?: {
-      broadcast?: (msg: ServerMessage) => void;
+      broadcast?: (msg: AssistantEvent) => void;
       assistantId?: string;
       trustContext?: TrustContext;
     },
@@ -260,8 +260,8 @@ export class CallController {
    * Kick off the first outbound call utterance from the assistant.
    */
   async startInitialGreeting(): Promise<void> {
-    if (this.initialGreetingStarted) return;
-    if (this.state !== "idle") return;
+    if (this.initialGreetingStarted) {return;}
+    if (this.state !== "idle") {return;}
 
     this.initialGreetingStarted = true;
     this.resetSilenceTimer();
@@ -275,8 +275,8 @@ export class CallController {
    * greet naturally with context that verification just happened.
    */
   async startPostVerificationGreeting(): Promise<void> {
-    if (this.initialGreetingStarted) return;
-    if (this.state !== "idle") return;
+    if (this.initialGreetingStarted) {return;}
+    if (this.state !== "idle") {return;}
 
     this.initialGreetingStarted = true;
     this.resetSilenceTimer();
@@ -473,10 +473,10 @@ export class CallController {
    */
   destroy(): void {
     this.destroyed = true;
-    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+    if (this.silenceTimer) {clearTimeout(this.silenceTimer);}
     this.cancelPendingEndCall();
-    if (this.durationTimer) clearTimeout(this.durationTimer);
-    if (this.durationWarningTimer) clearTimeout(this.durationWarningTimer);
+    if (this.durationTimer) {clearTimeout(this.durationTimer);}
+    if (this.durationWarningTimer) {clearTimeout(this.durationWarningTimer);}
     if (this.pendingGuardianInput) {
       clearTimeout(this.pendingGuardianInput.timer);
       this.pendingGuardianInput = null;
@@ -559,7 +559,7 @@ export class CallController {
     transcript: string,
     speaker?: PromptSpeakerContext,
   ): string {
-    if (!speaker) return transcript;
+    if (!speaker) {return transcript;}
     const safeId = speaker.speakerId.replaceAll('"', "'");
     const safeLabel = speaker.speakerLabel.replaceAll('"', "'");
     const confidencePart =
@@ -580,7 +580,7 @@ export class CallController {
   }
 
   private async runTurnInner(content: string): Promise<void> {
-    if (this.destroyed) return;
+    if (this.destroyed) {return;}
     const runVersion = ++this.llmRunVersion;
     const runSignal = this.abortController.signal;
 
@@ -603,7 +603,7 @@ export class CallController {
         runVersion,
         runSignal,
       );
-      if (!this.isCurrentRun(runVersion)) return;
+      if (!this.isCurrentRun(runVersion)) {return;}
 
       await this.handleTurnCompletion(fullResponseText);
     } catch (err: unknown) {
@@ -838,15 +838,15 @@ export class CallController {
         enqueueSynthesisSegments(synthProvider, segments);
       } else {
         const cleaned = sanitizeForTts(safeText);
-        if (cleaned.length === 0) return;
+        if (cleaned.length === 0) {return;}
         this.beginSpeakingOnAudioStart(runVersion);
         this.transport.sendTextToken(cleaned, false);
       }
     };
 
     const flushSafeText = (): void => {
-      if (!this.isCurrentRun(runVersion)) return;
-      if (ttsBuffer.length === 0) return;
+      if (!this.isCurrentRun(runVersion)) {return;}
+      if (ttsBuffer.length === 0) {return;}
       const bracketIdx = ttsBuffer.indexOf("[");
       if (bracketIdx === -1) {
         // No bracket at all — safe to flush everything
@@ -883,7 +883,7 @@ export class CallController {
     // Use a promise to track completion of the voice turn
     const turnComplete = new Promise<void>((resolve, reject) => {
       const onTextDelta = (text: string): void => {
-        if (!this.isCurrentRun(runVersion)) return;
+        if (!this.isCurrentRun(runVersion)) {return;}
         fullResponseText += text;
         ttsBuffer += text;
         ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
@@ -989,7 +989,7 @@ export class CallController {
     // latency; re-check the run wasn't superseded meanwhile so a stale turn
     // doesn't inject its end-of-turn marker (or fallback text) into the next
     // turn's output stream.
-    if (!this.isCurrentRun(runVersion)) return fullResponseText;
+    if (!this.isCurrentRun(runVersion)) {return fullResponseText;}
 
     // Signal end of this turn's speech.  An empty token with `last: true`
     // tells the transport to start listening — it does NOT trigger TTS
@@ -1447,7 +1447,7 @@ export class CallController {
   }
 
   private clearPendingGuardianInputForCallEnd(): boolean {
-    if (!this.pendingGuardianInput) return false;
+    if (!this.pendingGuardianInput) {return false;}
 
     clearTimeout(this.pendingGuardianInput.timer);
 
@@ -1476,7 +1476,7 @@ export class CallController {
     // The teardown has run to completion; drop the token so a later utterance
     // can't read it as a still-pending end-call.
     this.pendingEndCall = null;
-    if (this.destroyed) return;
+    if (this.destroyed) {return;}
 
     const currentSession = getCallSession(this.callSessionId);
     if (currentSession && isTerminalState(currentSession.status)) {
@@ -1518,7 +1518,7 @@ export class CallController {
   }
 
   private isExpectedAbortError(err: unknown): boolean {
-    if (!(err instanceof Error)) return false;
+    if (!(err instanceof Error)) {return false;}
     return err.name === "AbortError" || err.name === "APIUserAbortError";
   }
 
@@ -1541,7 +1541,7 @@ export class CallController {
    * waiting for the processing lock or generating with no audio yet.
    */
   private beginSpeaking(runVersion: number): void {
-    if (!this.isCurrentRun(runVersion)) return;
+    if (!this.isCurrentRun(runVersion)) {return;}
     if (this.state === "processing") {
       this.state = "speaking";
     }
@@ -1650,7 +1650,7 @@ export class CallController {
         !this.pendingGuardianInput ||
         this.pendingGuardianInput.questionId !== pendingQuestion.id
       )
-        return;
+        {return;}
 
       log.info(
         { callSessionId: this.callSessionId },
@@ -1727,8 +1727,8 @@ export class CallController {
    * Drain any instructions that were queued while the LLM was active.
    */
   private flushPendingInstructions(): void {
-    if (this.destroyed) return;
-    if (this.pendingInstructions.length === 0) return;
+    if (this.destroyed) {return;}
+    if (this.pendingInstructions.length === 0) {return;}
 
     const parts = this.pendingInstructions.map((instr) =>
       instr.startsWith("[") ? instr : `[USER_INSTRUCTION: ${instr}]`,
@@ -1814,8 +1814,8 @@ export class CallController {
   }
 
   private resetSilenceTimer(): void {
-    if (this.silenceTimer) clearTimeout(this.silenceTimer);
-    if (this.destroyed) return;
+    if (this.silenceTimer) {clearTimeout(this.silenceTimer);}
+    if (this.destroyed) {return;}
     this.silenceTimer = setTimeout(() => {
       // During an in-call guardian consultation, suppress the generic
       // "Are you still there?" — it is confusing when the caller is

package/src/calls/call-conversation-messages.ts

@@ -31,6 +31,56 @@ export function buildCallCompletionMessage(callSessionId: string): string {
   return buildCallSummaryLabel(callSession?.status, duration, events.length);
 }
 
+/** The `data` payload rendered by the `call_summary` surface. */
+interface CallSummaryEvent {
+  eventType: string;
+  payloadJson: string;
+  createdAt: number;
+}
+
+/**
+ * Build the `[ui_surface, text]` block pair persisted for a finished call.
+ *
+ * This is the approval-card pattern (see
+ * `notifications/approval-card-builder.ts`). Every provider drops `ui_surface`
+ * when serializing history, so the card alone left the model unable to tell
+ * that a call happened — the turn reached the wire as a "blocks omitted"
+ * sentinel (LUM-2869). The `_surfaceFallback` text sibling carries the same
+ * copy for the model, search indexing, CLI display, and channel replies, and
+ * its flag keeps surface-capable clients from rendering both the card and a
+ * duplicate text line.
+ */
+function buildCallSummaryBlocks(
+  summaryText: string,
+  status: string | undefined,
+  duration: number | null,
+  events: CallSummaryEvent[],
+): unknown[] {
+  return [
+    {
+      type: "ui_surface",
+      surfaceType: "call_summary",
+      surfaceId: crypto.randomUUID(),
+      completed: true,
+      data: {
+        summaryText,
+        status: status ?? "completed",
+        duration,
+        events: events.map((e) => ({
+          eventType: e.eventType,
+          payloadJson: e.payloadJson,
+          createdAt: e.createdAt,
+        })),
+      },
+    },
+    {
+      type: "text",
+      text: summaryText,
+      _surfaceFallback: true,
+    },
+  ];
+}
+
 export async function persistCallCompletionMessage(
   conversationId: string,
   callSessionId: string,
@@ -50,24 +100,14 @@ export async function persistCallCompletionMessage(
   await addMessage(
     conversationId,
     "assistant",
-    JSON.stringify([
-      {
-        type: "ui_surface",
-        surfaceType: "call_summary",
-        surfaceId: crypto.randomUUID(),
-        completed: true,
-        data: {
-          summaryText,
-          status: callSession?.status ?? "completed",
-          duration,
-          events: events.map((e) => ({
-            eventType: e.eventType,
-            payloadJson: e.payloadJson,
-            createdAt: e.createdAt,
-          })),
-        },
-      },
-    ]),
+    JSON.stringify(
+      buildCallSummaryBlocks(
+        summaryText,
+        callSession?.status,
+        duration,
+        events,
+      ),
+    ),
     {
       metadata: {
         userMessageChannel: "phone",

package/src/calls/voice-control-protocol.ts

@@ -28,6 +28,15 @@ export const END_CALL_MARKER = "[END_CALL]";
 export const HOLD_VERDICT_TOKEN = "[0]";
 export const ESCALATE_VERDICT_TOKEN = "[1]";
 
+/**
+ * Emitted inline by the main/escalated voice leg to ask the live-voice
+ * client to minimize the voice room and reveal the screen behind it
+ * (e.g. after creating an app worth showing). Advisory: the daemon
+ * translates it into a `minimize_room` server frame after the turn's TTS
+ * drains; it is never spoken and never persisted.
+ */
+export const MINIMIZE_ROOM_MARKER = "[-1]";
+
 // ---------------------------------------------------------------------------
 // Regexes
 // ---------------------------------------------------------------------------
@@ -47,6 +56,7 @@ const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
 const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
 const HOLD_VERDICT_TOKEN_REGEX = /\[0\]/g;
 const ESCALATE_VERDICT_TOKEN_REGEX = /\[1\]/g;
+const MINIMIZE_ROOM_MARKER_REGEX = /\[-1\]/g;
 const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
 const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
 
@@ -163,6 +173,7 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(END_CALL_MARKER_REGEX, "")
     .replace(HOLD_VERDICT_TOKEN_REGEX, "")
     .replace(ESCALATE_VERDICT_TOKEN_REGEX, "")
+    .replace(MINIMIZE_ROOM_MARKER_REGEX, "")
     .replace(GUARDIAN_TIMEOUT_MARKER_REGEX, "")
     .replace(GUARDIAN_UNAVAILABLE_MARKER_REGEX, "");
   return result;
@@ -187,6 +198,7 @@ const CONTROL_MARKER_STRINGS = [
   "[END_CALL]",
   "[0]",
   "[1]",
+  "[-1]",
   "[GUARDIAN_TIMEOUT]",
   "[GUARDIAN_UNAVAILABLE]",
 ];
@@ -203,3 +215,47 @@ export function couldBeControlMarker(text: string): boolean {
     (marker) => marker.startsWith(text) || text.startsWith(marker),
   );
 }
+
+// Colon-style markers whose bodies terminate at the first "]" — their strip
+// regexes are non-greedy (`.+?\]`), so the first bracket IS the terminator.
+// ASK_GUARDIAN_APPROVAL is deliberately absent: its balanced-JSON body may
+// itself contain "]" (arrays, string values), so only the balanced parser can
+// judge it complete.
+const FIRST_BRACKET_TERMINATED_PREFIXES = [
+  "[ASK_GUARDIAN:",
+  "[USER_ANSWERED:",
+  "[USER_INSTRUCTION:",
+];
+
+const GUARDIAN_APPROVAL_PREFIX = "[ASK_GUARDIAN_APPROVAL:";
+
+/**
+ * Whether `tail` (a buffer starting at a `[`) is a control marker that is
+ * still streaming — i.e. holding it back is required because
+ * {@link stripInternalSpeechMarkers} cannot yet remove it. Returns false for
+ * complete markers (safe to flush: stripping removes them) and for text that
+ * is not a marker at all (safe to flush: it is speech).
+ *
+ * Completion is judged per marker family: a strict prefix of any known
+ * marker string is always incomplete; an ASK_GUARDIAN_APPROVAL body is
+ * complete only when {@link extractBalancedJson} finds the balanced JSON and
+ * its closing bracket (a bare "]" inside the JSON does NOT terminate it);
+ * the other colon-style markers terminate at their first "]"; the fixed
+ * literal markers are complete the moment they match.
+ */
+export function isIncompleteControlMarkerTail(tail: string): boolean {
+  if (
+    CONTROL_MARKER_STRINGS.some(
+      (marker) => marker.length > tail.length && marker.startsWith(tail),
+    )
+  ) {
+    return true;
+  }
+  if (tail.startsWith(GUARDIAN_APPROVAL_PREFIX)) {
+    return extractBalancedJson(tail) === null;
+  }
+  if (FIRST_BRACKET_TERMINATED_PREFIXES.some((p) => tail.startsWith(p))) {
+    return !tail.includes("]");
+  }
+  return false;
+}