@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/live-voice/__tests__/front-decision.test.ts

@@ -1,10 +1,11 @@
 /**
- * Tests for the VoiceFrontDecider endpoint-decision service.
+ * Tests for the VoiceFrontDecider spoken-text service.
  *
  * The provider is injected via the `getProvider` seam (live-voice DI
- * convention), so no module mocking is needed. The tests pin the fail-open
+ * convention), so no module mocking is needed. The tests pin the fail-soft
  * contract: every failure mode (null provider, timeout, thrown error, caller
- * abort) resolves to "release" within the configured budget.
+ * abort) resolves to `null` within the configured budget, and the caller
+ * speaks nothing.
  *
  * generateAckText and generateProgressText share one implementation
  * (`generateBoundedSpokenText`), so their common failure modes are pinned in
@@ -19,20 +20,12 @@ import type { Provider, ProviderResponse } from "../../providers/types.js";
 import {
   createVoiceFrontDecider,
   type VoiceAckTextInput,
-  type VoiceEndpointDecisionInput,
   type VoiceFrontDecider,
   type VoiceProgressTextInput,
 } from "../front-decision.js";
 
 const config = LiveVoiceFrontModelConfigSchema.parse({});
 
-const input: VoiceEndpointDecisionInput = {
-  transcriptSoFar: "so what I was thinking is",
-  latestPartial: null,
-  silenceThresholdMs: 1200,
-  extensionCount: 0,
-};
-
 const ackInput: VoiceAckTextInput = {
   transcriptSoFar: "can you check my calendar for tomorrow",
 };
@@ -71,171 +64,6 @@ function toolResponse(
   };
 }
 
-function textResponse(text: string): ProviderResponse {
-  return {
-    content: [{ type: "text", text }],
-    model: "stub-model",
-    usage: { inputTokens: 1, outputTokens: 1 },
-    stopReason: "end_turn",
-  };
-}
-
-describe("createVoiceFrontDecider — decideEndpoint", () => {
-  test('answer "0" → hold', async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse("0")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "hold" });
-  });
-
-  test('answer "1" → release', async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse("1")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test('answer "0" with trailing delimiter → hold', async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse(" 0\n")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "hold" });
-  });
-
-  test("sends transcript, tight token budget, no tools, and call-site config", async () => {
-    let captured: Parameters<Provider["sendMessage"]> | undefined;
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async (...args) => {
-          captured = args;
-          return textResponse("1");
-        }),
-    });
-    await decider.decideEndpoint({ ...input, latestPartial: "and then" });
-
-    const [messages, options] = captured!;
-    expect(messages).toHaveLength(1);
-    const text = (messages[0].content[0] as { text: string }).text;
-    expect(text).toContain("so what I was thinking is");
-    expect(text).toContain("and then");
-    expect(options?.config).toMatchObject({
-      max_tokens: 4,
-      callSite: "voiceFrontDecision",
-      disableCache: true,
-    });
-    // Single-token text protocol: no tool schema in the prompt, no forced
-    // tool call in the output — the latency-critical path stays minimal.
-    expect(options?.tools).toBeUndefined();
-    expect(options?.config?.tool_choice).toBeUndefined();
-    expect(options?.systemPrompt).toContain("finished");
-  });
-
-  test("null provider → release (fail-open)", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => null,
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("provider resolution throws → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => {
-        throw new Error("resolution boom");
-      },
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("getProvider that never resolves → release after endpointDecisionTimeoutMs", async () => {
-    const decider = createVoiceFrontDecider({
-      config: LiveVoiceFrontModelConfigSchema.parse({
-        endpointDecisionTimeoutMs: 20,
-      }),
-      // Stalled lazy provider initialization — the timeout must bound the
-      // whole call including resolution, not just sendMessage.
-      getProvider: () => new Promise<Provider | null>(() => {}),
-    });
-    const start = Date.now();
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-    expect(Date.now() - start).toBeLessThan(1000);
-  });
-
-  test("sendMessage that never resolves → release after endpointDecisionTimeoutMs", async () => {
-    const decider = createVoiceFrontDecider({
-      config: LiveVoiceFrontModelConfigSchema.parse({
-        endpointDecisionTimeoutMs: 20,
-      }),
-      // Never settles and ignores the abort signal entirely — the decider's
-      // own timeout race must still bound the call.
-      getProvider: async () =>
-        stubProvider(() => new Promise<ProviderResponse>(() => {})),
-    });
-    const start = Date.now();
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-    expect(Date.now() - start).toBeLessThan(1000);
-  });
-
-  test("sendMessage throws → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async () => {
-          throw new Error("provider boom");
-        }),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("caller-signal abort → release promptly", async () => {
-    const decider = createVoiceFrontDecider({
-      // Long timeout so only the caller's abort can end the call early.
-      config: LiveVoiceFrontModelConfigSchema.parse({
-        endpointDecisionTimeoutMs: 60_000,
-      }),
-      getProvider: async () =>
-        stubProvider(() => new Promise<ProviderResponse>(() => {})),
-    });
-    const controller = new AbortController();
-    const pending = decider.decideEndpoint(input, controller.signal);
-    controller.abort();
-    const start = Date.now();
-    expect(await pending).toEqual({ action: "release" });
-    expect(Date.now() - start).toBeLessThan(1000);
-  });
-
-  test("response without a text block → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async () => toolResponse({ complete: false })),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("empty text answer → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse("   ")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("non-protocol prose answer → release (fail-open)", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async () => textResponse("The speaker seems unsure")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-});
-
 /**
  * One case per spoken-text method, carrying the values that differ between
  * them: the forced tool, the tool-input field, the length cap, the timeout

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

@@ -10,7 +10,7 @@ import type {
   StreamingTranscriber,
   SttStreamServerEvent,
 } from "../../stt/types.js";
-import { pickAckPhrase } from "../ack-phrases.js";
+import type { VoiceFrontDecider } from "../front-decision.js";
 import {
   LiveVoiceSession,
   type LiveVoiceTtsStreamer,
@@ -97,6 +97,7 @@ function createSessionHarness(
     emitMetrics?: boolean;
     streamTtsAudio?: LiveVoiceTtsStreamer;
     frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
+    frontDecider?: VoiceFrontDecider;
   } = {},
 ) {
   const transcriber =
@@ -121,6 +122,7 @@ function createSessionHarness(
     ...(options.frontModelConfig
       ? { frontModelConfig: options.frontModelConfig }
       : {}),
+    ...(options.frontDecider ? { frontDecider: options.frontDecider } : {}),
   });
 
   return { frames, session, startVoiceTurn, transcriber };
@@ -144,12 +146,80 @@ async function waitFor(
   message = "Timed out waiting for live voice assistant turn condition",
 ): Promise<void> {
   for (let attempt = 0; attempt < 40; attempt += 1) {
-    if (predicate()) return;
+    if (predicate()) {
+      return;
+    }
     await new Promise((resolve) => setTimeout(resolve, 5));
   }
   throw new Error(message);
 }
 
+function createCapturingTurnStarter(): {
+  startVoiceTurn: LiveVoiceTurnStarter;
+  getCallbacks: () => VoiceTurnCallbacks | undefined;
+} {
+  let callbacks: VoiceTurnCallbacks | undefined;
+  const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+    callbacks = options.callbacks;
+    return { turnId: "bridge-turn-1", abort: mock() };
+  });
+  return { startVoiceTurn, getCallbacks: () => callbacks };
+}
+
+function createRecordingTtsStreamer(): {
+  streamTtsAudio: LiveVoiceTtsStreamer;
+  ttsTexts: string[];
+} {
+  const ttsTexts: string[] = [];
+  const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+    ttsTexts.push(options.text);
+    return {
+      provider: "fish-audio" as const,
+      contentType: "audio/pcm",
+      sampleRate: 24_000,
+      chunks: 1,
+      bytes: Buffer.byteLength(options.text),
+    };
+  });
+  return { streamTtsAudio, ttsTexts };
+}
+
+function emitTextDelta(
+  getCallbacks: () => VoiceTurnCallbacks | undefined,
+  text: string,
+): void {
+  getCallbacks()?.assistant_text_delta?.({
+    type: "assistant_text_delta",
+    text,
+    conversationId: "conversation-123",
+  });
+}
+
+function emitMessageComplete(
+  getCallbacks: () => VoiceTurnCallbacks | undefined,
+): void {
+  getCallbacks()?.message_complete?.({
+    type: "message_complete",
+    conversationId: "conversation-123",
+    messageId: "assistant-message-123",
+  });
+}
+
+async function startReleasedTurn(
+  session: LiveVoiceSession,
+  getCallbacks: () => VoiceTurnCallbacks | undefined,
+): Promise<void> {
+  await session.start();
+  await session.handleClientFrame({ type: "ptt_release" });
+  await waitFor(() => getCallbacks() !== undefined);
+}
+
+function assistantDeltaTexts(frames: LiveVoiceServerFrame[]): string[] {
+  return frames.flatMap((frame) =>
+    frame.type === "assistant_text_delta" ? [frame.text] : [],
+  );
+}
+
 describe("LiveVoiceSession assistant turn", () => {
   test("runs final transcripts through the voice bridge and forwards ordered assistant events", async () => {
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
@@ -457,63 +527,19 @@ describe("LiveVoiceSession assistant turn", () => {
 
 describe("LiveVoiceSession tool-use spoken ack", () => {
   const ACK_TIMEOUT_MS = 40;
-  // Acks pass through the same TTS sanitizer as regular segments; each fresh
-  // session's phrase counter starts at 0.
-  const EXPECTED_TOOL_ACK = sanitizeForTts(pickAckPhrase("tool_use", 0)).trim();
-  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(
-    pickAckPhrase("first_delta", 0),
-  ).trim();
-
-  function createCapturingTurnStarter(): {
-    startVoiceTurn: LiveVoiceTurnStarter;
-    getCallbacks: () => VoiceTurnCallbacks | undefined;
-  } {
-    let callbacks: VoiceTurnCallbacks | undefined;
-    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
-      callbacks = options.callbacks;
-      return { turnId: "bridge-turn-1", abort: mock() };
-    });
-    return { startVoiceTurn, getCallbacks: () => callbacks };
-  }
-
-  function createRecordingTtsStreamer(): {
-    streamTtsAudio: LiveVoiceTtsStreamer;
-    ttsTexts: string[];
-  } {
-    const ttsTexts: string[] = [];
-    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
-      ttsTexts.push(options.text);
-      return {
-        provider: "fish-audio" as const,
-        contentType: "audio/pcm",
-        sampleRate: 24_000,
-        chunks: 1,
-        bytes: Buffer.byteLength(options.text),
-      };
-    });
-    return { streamTtsAudio, ttsTexts };
-  }
-
-  function emitTextDelta(
-    getCallbacks: () => VoiceTurnCallbacks | undefined,
-    text: string,
-  ): void {
-    getCallbacks()?.assistant_text_delta?.({
-      type: "assistant_text_delta",
-      text,
-      conversationId: "conversation-123",
-    });
-  }
-
-  function emitMessageComplete(
-    getCallbacks: () => VoiceTurnCallbacks | undefined,
-  ): void {
-    getCallbacks()?.message_complete?.({
-      type: "message_complete",
-      conversationId: "conversation-123",
-      messageId: "assistant-message-123",
-    });
-  }
+  // Every ack is front-model-phrased; the generated text passes through the
+  // same TTS sanitizer as regular segments. The stub varies its phrasing by
+  // trigger so the two ack kinds stay distinguishable in assertions.
+  const TOOL_ACK = "Let me look that up.";
+  const FIRST_DELTA_ACK = "Sure — one moment.";
+  const EXPECTED_TOOL_ACK = sanitizeForTts(TOOL_ACK).trim();
+  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(FIRST_DELTA_ACK).trim();
+
+  const ackDecider: VoiceFrontDecider = {
+    generateAckText: async (input) =>
+      input.toolName ? TOOL_ACK : FIRST_DELTA_ACK,
+    generateProgressText: async () => null,
+  };
 
   function createAckHarness() {
     const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
@@ -522,19 +548,11 @@ describe("LiveVoiceSession tool-use spoken ack", () => {
       startVoiceTurn,
       streamTtsAudio,
       frontModelConfig: { ackFirstDeltaTimeoutMs: ACK_TIMEOUT_MS },
+      frontDecider: ackDecider,
     });
     return { ...harness, getCallbacks, ttsTexts };
   }
 
-  async function startReleasedTurn(
-    session: LiveVoiceSession,
-    getCallbacks: () => VoiceTurnCallbacks | undefined,
-  ): Promise<void> {
-    await session.start();
-    await session.handleClientFrame({ type: "ptt_release" });
-    await waitFor(() => getCallbacks() !== undefined);
-  }
-
   test("tool_use_start before any delta speaks an immediate tool ack and cancels the timer", async () => {
     const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
 
@@ -590,3 +608,193 @@ describe("LiveVoiceSession tool-use spoken ack", () => {
     expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK, "Hello there."]);
   });
 });
+
+describe("LiveVoiceSession minimize-room marker", () => {
+  function createMarkerHarness() {
+    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const harness = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+      // Deltas are emitted immediately in these runs; a long ack budget keeps
+      // filler phrases out of the recorded TTS text.
+      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
+    });
+    return { ...harness, getCallbacks, ttsTexts };
+  }
+
+  /**
+   * 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`.
+   */
+  function createEscalatedMarkerHarness() {
+    let escalatedCallbacks: VoiceTurnCallbacks | undefined;
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      if (options.routingLeg === "front-door") {
+        queueMicrotask(() => {
+          options.callbacks?.assistant_text_delta?.({
+            type: "assistant_text_delta",
+            text: "[1] Working on it.",
+            conversationId: "conversation-123",
+          });
+          options.callbacks?.message_complete?.({
+            type: "message_complete",
+            conversationId: "conversation-123",
+            messageId: "front-door-message",
+          });
+        });
+        return { turnId: "bridge-turn-fd", abort: mock() };
+      }
+      escalatedCallbacks = options.callbacks;
+      return { turnId: "bridge-turn-esc", abort: mock() };
+    });
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const harness = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
+    });
+    return {
+      ...harness,
+      getCallbacks: () => escalatedCallbacks,
+      ttsTexts,
+    };
+  }
+
+  test("strips a terminal [-1] from deltas and TTS and emits minimize_room after tts_done", 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 === "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);
+    expect(minimizeIndex).toBeGreaterThan(ttsDoneIndex);
+    expect(frames[minimizeIndex]).toMatchObject({
+      type: "minimize_room",
+      turnId: "live-turn-1",
+    });
+    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 () => {
+    const { frames, session, getCallbacks, ttsTexts } =
+      createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "One sec, done. [-");
+    await flushAsyncCallbacks();
+    expect(assistantDeltaTexts(frames).join("")).toContain("One sec, done. ");
+
+    emitTextDelta(getCallbacks, "1]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
+
+    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 () => {
+    const { frames, session, getCallbacks } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "The array [-1] sorts first, then the rest.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toBe(
+      "The array  sorts first, then the rest.",
+    );
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("does not emit minimize_room when the turn is interrupted before drain", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Minimizing now. [-1]");
+    await flushAsyncCallbacks();
+
+    await session.handleClientFrame({ type: "interrupt" });
+    emitMessageComplete(getCallbacks);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("a turn without the marker emits no minimize_room frame", async () => {
+    const { frames, session, getCallbacks } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Hello there.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toBe("Hello there.");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("strips a stray [END_CALL] from main-leg deltas and TTS", async () => {
+    const { frames, session, getCallbacks, ttsTexts } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Bye now. [END_CALL]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toBe("Bye now. ");
+    expect(ttsTexts.join(" ")).not.toContain("[END_CALL]");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("a held marker-like tail that never completes is emitted at completion", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Score was [-");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toContain("Score was [-");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("holds a guardian-approval marker whose JSON body contains brackets, then strips it whole", async () => {
+    const { frames, session, getCallbacks, ttsTexts } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    // The JSON body carries both a "]" inside a string value and a nested
+    // array — neither may terminate the hold or mask the marker's start.
+    emitTextDelta(
+      getCallbacks,
+      'Hold on. [ASK_GUARDIAN_APPROVAL: {"question": "ok]?", "options": ["a", "b"',
+    );
+    await flushAsyncCallbacks();
+    expect(assistantDeltaTexts(frames).join("")).toBe("Hold on. ");
+
+    emitTextDelta(getCallbacks, "]}] Anything else?");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    const joined = assistantDeltaTexts(frames).join("");
+    expect(joined).not.toContain("ASK_GUARDIAN_APPROVAL");
+    expect(joined).toContain("Anything else?");
+    expect(ttsTexts.join(" ")).not.toContain("ASK_GUARDIAN_APPROVAL");
+  });
+});

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

@@ -253,9 +253,12 @@ describe("LiveVoiceSession archive and metrics events", () => {
       assistantMessageChannel: "vellum",
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
-      // Pins the full production control prompt, including the no-UI rule
-      // (voice turns are non-interactive — everything is conveyed in speech)
-      // and the shared no-setup-flows rule (no OAuth/browser flows mid-call).
+      // Pins the full production control prompt for the FRONT-DOOR leg (the
+      // first leg of every routed turn): the no-UI rule (voice turns are
+      // non-interactive — everything is conveyed in speech) and the shared
+      // no-setup-flows rule (no OAuth/browser flows mid-call). The [-1]
+      // room-minimize teaching is deliberately absent — only the escalated
+      // leg learns it (see live-voice-triage-escalate.test.ts).
       voiceControlPrompt:
         "You are speaking in a local live voice session. Keep replies brief and conversational. You cannot display cards, forms, or any on-screen UI during the call — convey everything in speech. " +
         VOICE_NO_SETUP_FLOWS_RULE,