@vellumai/assistant 0.12.1 → 0.12.2-staging.2

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

@@ -1,5 +1,14 @@
 import { describe, expect, mock, test } from "bun:test";
 
+import type {
+  VoiceProgressNarrator,
+  VoiceProgressTextInput,
+} from "../../calls/progress-narration.js";
+import {
+  pickProgressPhrase,
+  PROGRESS_FALLBACK_PHRASES,
+  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
+} from "../../calls/progress-phrases.js";
 import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type {
   VoiceTurnCallbacks,
@@ -7,9 +16,9 @@ import type {
 } from "../../calls/voice-session-bridge.js";
 import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import type {
-  LiveVoiceFrontModelConfig,
-  LiveVoiceProgressConfig,
-} from "../../config/schemas/live-voice.js";
+  VoiceFrontModelConfig,
+  VoiceProgressConfig,
+} from "../../config/schemas/voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -21,15 +30,6 @@ import {
 } from "../live-voice-session.js";
 import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
 import type { LiveVoiceTtsOptions } from "../live-voice-tts.js";
-import type {
-  VoiceProgressNarrator,
-  VoiceProgressTextInput,
-} from "../progress-narration.js";
-import {
-  pickProgressPhrase,
-  PROGRESS_FALLBACK_PHRASES,
-  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
-} from "../progress-phrases.js";
 import {
   createLiveVoiceServerFrameSequencer,
   type LiveVoiceClientStartFrame,
@@ -142,8 +142,8 @@ function makeProgressNarrator(
 }
 
 function progressConfig(
-  overrides: Partial<LiveVoiceProgressConfig> = {},
-): Partial<LiveVoiceFrontModelConfig> {
+  overrides: Partial<VoiceProgressConfig> = {},
+): Partial<VoiceFrontModelConfig> {
   const idleIntervalMs = overrides.idleIntervalMs ?? 60_000;
   return {
     progress: {
@@ -163,7 +163,7 @@ function progressConfig(
 }
 
 function createProgressHarness(options: {
-  frontModelConfig: Partial<LiveVoiceFrontModelConfig>;
+  frontModelConfig: Partial<VoiceFrontModelConfig>;
   progressNarrator: VoiceProgressNarrator;
   emitMetrics?: boolean;
   gateTtsText?: (text: string) => Promise<void> | null;
@@ -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-sight-frame-echo.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, mock, spyOn, test } from "bun:test";
+
+import {
+  createMockProvider,
+  textResponse,
+} from "../../__tests__/helpers/mock-provider.js";
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import { waitFor } from "../../__tests__/helpers/wait-for.js";
+
+setConfig("memory", { enabled: false });
+
+import { UserMessageEchoEventSchema } from "../../api/events/user-message-echo.js";
+import type { AssistantEventEnvelope } from "../../api/index.js";
+import { Conversation } from "../../daemon/conversation.js";
+import * as conversationMessaging from "../../daemon/conversation-messaging.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../../daemon/conversation-registry.js";
+import { conversationMessagesSyncTag } from "../../daemon/message-types/sync.js";
+import { uploadAttachment } from "../../persistence/attachments-store.js";
+import * as conversationCrud from "../../persistence/conversation-crud.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
+import {
+  _drainFrameReclaimRechecksForTests,
+  _pendingFrameReclaimCountForTests,
+  persistAmbientSightFrame,
+  persistLiveVoicePhoto,
+} from "../live-voice-photo.js";
+import { LiveVoiceSession } from "../live-voice-session.js";
+import { createLiveVoiceServerFrameSequencer } from "../protocol.js";
+
+await initializeDb();
+
+function createHarness() {
+  const row = conversationCrud.createConversation("Camera frame echo");
+  const { provider } = createMockProvider([textResponse("")]);
+  const conversation = new Conversation(
+    row.id,
+    provider,
+    "system prompt",
+    () => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+  conversation.setTrustContext({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  });
+  setConversation(row.id, conversation);
+
+  const sequencer = createLiveVoiceServerFrameSequencer();
+  const startVoiceTurn = mock(async () => ({
+    turnId: "turn-123",
+    abort: mock(),
+  }));
+  const session = new LiveVoiceSession(
+    {
+      sessionId: "session-123",
+      startFrame: {
+        type: "start",
+        conversationId: row.id,
+        audio: { mimeType: "audio/pcm", sampleRate: 24_000, channels: 1 },
+      },
+      sendFrame: async (payload) => sequencer.next(payload),
+    },
+    {
+      resolveTranscriber: async () => ({
+        providerId: "deepgram",
+        boundaryId: "daemon-streaming",
+        async start() {},
+        sendAudio() {},
+        stop() {},
+      }),
+      startVoiceTurn,
+      emitMetrics: false,
+    },
+  );
+  const published: {
+    event: AssistantEventEnvelope;
+    persistedIds: string[];
+    persistedSeq: number | null;
+  }[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    filter: { conversationId: row.id },
+    callback: (event) => {
+      if (
+        (event.message.type === "user_message_echo" &&
+          event.message.conversationId === row.id) ||
+        (event.message.type === "sync_changed" &&
+          event.message.tags.includes(conversationMessagesSyncTag(row.id)))
+      ) {
+        published.push({
+          event,
+          persistedIds: conversationCrud.getMessages(row.id).map((m) => m.id),
+          persistedSeq: conversationCrud.getConversationPersistedSeq(row.id),
+        });
+      }
+    },
+  });
+
+  return {
+    conversationId: row.id,
+    session,
+    startVoiceTurn,
+    published,
+    async dispose() {
+      subscription.dispose();
+      await session.close("client_end");
+      deleteConversation(row.id);
+      conversation.dispose();
+    },
+  };
+}
+
+async function uploadFrame(): Promise<string> {
+  const attachment = await uploadAttachment(
+    "frame.png",
+    "image/png",
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk",
+  );
+  return attachment.id;
+}
+
+async function expectAnnouncement(
+  harness: ReturnType<typeof createHarness>,
+  cameraFrame: boolean,
+): Promise<void> {
+  await waitFor(() => harness.published.length >= 2);
+  expect(harness.published.map(({ event }) => event.message.type)).toEqual([
+    "user_message_echo",
+    "sync_changed",
+  ]);
+  const [echo, sync] = harness.published;
+  const message = UserMessageEchoEventSchema.parse(echo.event.message);
+  const rows = conversationCrud.getMessages(harness.conversationId);
+  expect(rows).toHaveLength(1);
+  expect(message.messageId).toBe(rows[0].id);
+  expect(echo.persistedIds).toEqual([rows[0].id]);
+  expect(echo.event.seq).toBeNumber();
+  expect(sync.persistedSeq).toBe(echo.event.seq!);
+  expect(message.text).toBe(cameraFrame ? "(camera frame)" : "here's a photo:");
+  if (cameraFrame) {
+    expect(message.cameraFrame).toBe(true);
+  } else {
+    expect(echo.event.message).not.toHaveProperty("cameraFrame");
+  }
+  expect(harness.startVoiceTurn).not.toHaveBeenCalled();
+}
+
+describe("standalone image echoes", () => {
+  test.each(["sight_frame", "attach_image"] as const)(
+    "%s emits one committed row before the history invalidation",
+    async (type) => {
+      const harness = createHarness();
+      try {
+        await harness.session.start();
+        const attachmentId = await uploadFrame();
+        await harness.session.handleClientFrame({ type, attachmentId });
+        await expectAnnouncement(harness, type === "sight_frame");
+      } finally {
+        await harness.dispose();
+      }
+    },
+  );
+
+  test.each([
+    { kind: "sight_frame", deferred: false },
+    { kind: "photo", deferred: false },
+    { kind: "sight_frame", deferred: true },
+  ] as const)(
+    "$kind preserves its echo marker when a committed write throws (deferred: $deferred)",
+    async ({ kind, deferred }) => {
+      const harness = createHarness();
+      const realPersist = conversationMessaging.persistQueuedMessageBody;
+      const realGetMessage = conversationCrud.getMessageById;
+      let committed = false;
+      const persist = spyOn(
+        conversationMessaging,
+        "persistQueuedMessageBody",
+      ).mockImplementation(async (...args) => {
+        await realPersist(...args);
+        committed = true;
+        throw new Error("Post-insert write failed");
+      });
+      const read = spyOn(conversationCrud, "getMessageById").mockImplementation(
+        (...args) => {
+          if (deferred && committed) {
+            throw new Error("Store temporarily unreadable");
+          }
+          return realGetMessage(...args);
+        },
+      );
+      try {
+        const attachmentId = await uploadFrame();
+        const result =
+          kind === "sight_frame"
+            ? await persistAmbientSightFrame(
+                harness.conversationId,
+                attachmentId,
+                "voice",
+              )
+            : await persistLiveVoicePhoto(harness.conversationId, attachmentId);
+        expect(result.ok).toBe(!deferred);
+        if (deferred) {
+          expect(harness.published).toHaveLength(0);
+          expect(_pendingFrameReclaimCountForTests()).toBe(1);
+          _drainFrameReclaimRechecksForTests();
+          expect(_pendingFrameReclaimCountForTests()).toBe(1);
+          read.mockRestore();
+          _drainFrameReclaimRechecksForTests();
+          _drainFrameReclaimRechecksForTests();
+          expect(_pendingFrameReclaimCountForTests()).toBe(0);
+        }
+        await expectAnnouncement(harness, kind === "sight_frame");
+      } finally {
+        persist.mockRestore();
+        read.mockRestore();
+        _drainFrameReclaimRechecksForTests();
+        await harness.dispose();
+      }
+    },
+  );
+
+  test("the strict echo schema accepts only a true camera marker", () => {
+    const echo = { type: "user_message_echo", text: "(camera frame)" };
+    expect(
+      UserMessageEchoEventSchema.safeParse({ ...echo, cameraFrame: false })
+        .success,
+    ).toBe(false);
+    expect(
+      UserMessageEchoEventSchema.safeParse({ ...echo, unexpected: true })
+        .success,
+    ).toBe(false);
+  });
+});

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

@@ -12,7 +12,7 @@ import {
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import type { LiveVoiceFrontModelConfig } from "../../config/schemas/live-voice.js";
+import type { VoiceFrontModelConfig } from "../../config/schemas/voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -183,7 +183,7 @@ function createHarness(options: {
   echoBargeInMargin?: number;
   echoEmaHalfLifeMs?: number;
   echoDrainSlackMs?: number;
-  frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
+  frontModelConfig?: Partial<VoiceFrontModelConfig>;
   emitMetrics?: boolean;
   metricsClock?: () => number;
   // Return a promise to hold a frame's transport write open (a backed-up

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

@@ -698,6 +698,45 @@ describe("parseLiveVoiceClientTextFrame", () => {
     });
   });
 
+  test("keeps known session controls and drops unknown ones", () => {
+    const result = validateLiveVoiceClientFrame({
+      type: "start",
+      sessionControls: ["mute", "look_screen", "end", "mute", 7],
+      audio: { mimeType: "audio/pcm", sampleRate: 24000, channels: 1 },
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    // A newer client's controls cost it nothing on an older daemon.
+    expect(result.frame).toMatchObject({
+      type: "start",
+      sessionControls: ["end", "mute"],
+    });
+  });
+
+  test.each([
+    ["absent", {}],
+    ["not an array", { sessionControls: "end" }],
+    ["all unknown", { sessionControls: ["look_screen"] }],
+  ])(
+    "omits sessionControls from the start frame when %s",
+    (_label, extra: Record<string, unknown>) => {
+      const result = validateLiveVoiceClientFrame({
+        type: "start",
+        ...extra,
+        audio: { mimeType: "audio/pcm", sampleRate: 24000, channels: 1 },
+      });
+
+      expect(result.ok).toBe(true);
+      if (!result.ok) {
+        return;
+      }
+      expect("sessionControls" in result.frame).toBe(false);
+    },
+  );
+
   test("parses the textInput capability on the start frame", () => {
     const result = validateLiveVoiceClientFrame({
       type: "start",

package/src/live-voice/__tests__/runtime-websocket-shell.test.ts

@@ -92,36 +92,17 @@ mock.module("../live-voice-credential-preflight.js", () => ({
       : realPreflightModule.resolveLiveVoiceCredentialReadiness(),
 }));
 
-import { CURRENT_POLICY_EPOCH } from "../../runtime/auth/policy.js";
-import { mintToken } from "../../runtime/auth/token-service.js";
+import {
+  mintActorToken,
+  mintGatewayToken,
+  requireHttpAuth,
+  upgradeHeaders,
+  waitForClose,
+} from "../../runtime/__tests__/runtime-ws-test-utils.js";
 import { RuntimeHttpServer } from "../../runtime/http-server.js";
 
 type JsonFrame = Record<string, unknown>;
 
-const savedAuthEnv = {
-  DISABLE_HTTP_AUTH: process.env.DISABLE_HTTP_AUTH,
-};
-
-function mintGatewayToken(): string {
-  return mintToken({
-    aud: "vellum-daemon",
-    sub: "svc:gateway:self",
-    scope_profile: "gateway_ingress_v1",
-    policy_epoch: CURRENT_POLICY_EPOCH,
-    ttlSeconds: 3600,
-  });
-}
-
-function mintActorToken(): string {
-  return mintToken({
-    aud: "vellum-daemon",
-    sub: "actor:self:user-123",
-    scope_profile: "actor_client_v1",
-    policy_epoch: CURRENT_POLICY_EPOCH,
-    ttlSeconds: 3600,
-  });
-}
-
 function startFrame(conversationId = "conversation-123"): string {
   return JSON.stringify({
     type: "start",
@@ -161,33 +142,6 @@ async function waitForOpen(ws: WebSocket, timeoutMs = 2000): Promise<void> {
   });
 }
 
-async function waitForClose(ws: WebSocket, timeoutMs = 2000): Promise<void> {
-  if (ws.readyState === WebSocket.CLOSED) {
-    return;
-  }
-  await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      reject(new Error("Timed out waiting for WebSocket close"));
-    }, timeoutMs);
-    const cleanup = () => {
-      clearTimeout(timer);
-      ws.removeEventListener("close", onClose);
-      ws.removeEventListener("error", onError);
-    };
-    const onClose = () => {
-      cleanup();
-      resolve();
-    };
-    const onError = () => {
-      cleanup();
-      reject(new Error("WebSocket close failed"));
-    };
-    ws.addEventListener("close", onClose);
-    ws.addEventListener("error", onError);
-  });
-}
-
 async function waitForJsonFrame(
   ws: WebSocket,
   timeoutMs = 2000,
@@ -241,6 +195,7 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
   let baseUrl: string;
   let wsBaseUrl: string;
   let clients: WebSocket[];
+  let restoreAuthEnv: () => void;
 
   beforeAll(() => {
     shellMocksActive = true;
@@ -251,7 +206,7 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
   });
 
   beforeEach(async () => {
-    delete process.env.DISABLE_HTTP_AUTH;
+    restoreAuthEnv = requireHttpAuth();
     resolveStreamingTranscriberImpl = async () => createResolvedTranscriber();
     resolveStreamingTranscriberMock.mockClear();
     resolvedTranscribers.length = 0;
@@ -268,11 +223,7 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
       closeClient(client);
     }
     await server.stop();
-    if (savedAuthEnv.DISABLE_HTTP_AUTH === undefined) {
-      delete process.env.DISABLE_HTTP_AUTH;
-    } else {
-      process.env.DISABLE_HTTP_AUTH = savedAuthEnv.DISABLE_HTTP_AUTH;
-    }
+    restoreAuthEnv();
   });
 
   function openLiveVoiceClient(token = mintGatewayToken()): WebSocket {
@@ -284,21 +235,14 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
   }
 
   test("rejects unauthorized upgrades before creating a WebSocket", async () => {
-    const baseHeaders = {
-      Upgrade: "websocket",
-      Connection: "Upgrade",
-      "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
-      "Sec-WebSocket-Version": "13",
-    };
-
     const missingToken = await fetch(`${baseUrl}/v1/live-voice`, {
-      headers: baseHeaders,
+      headers: upgradeHeaders,
     });
     expect(missingToken.status).toBe(401);
 
     const actorToken = await fetch(
       `${baseUrl}/v1/live-voice?token=${mintActorToken()}`,
-      { headers: baseHeaders },
+      { headers: upgradeHeaders },
     );
     expect(actorToken.status).toBe(401);
 
@@ -306,7 +250,7 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
       `${baseUrl}/v1/live-voice?token=${mintGatewayToken()}`,
       {
         headers: {
-          ...baseHeaders,
+          ...upgradeHeaders,
           Origin: "https://external.example.com",
         },
       },

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

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+
+import type { VoiceProgressConfig } from "../../config/schemas/voice.js";
+import {
+  FEWER_UPDATES_INTERVAL_MS,
+  progressConfigForCadence,
+  requestedSessionControl,
+  sessionControlTeaching,
+} from "../session-controls.js";
+
+const CONFIG: VoiceProgressConfig = {
+  enabled: true,
+  opsThreshold: 3,
+  idleIntervalMs: 5_000,
+  maxSilenceMs: 35_000,
+  longOpMs: 15_000,
+  minGapMs: 6_000,
+  generationTimeoutMs: 1_500,
+};
+
+describe("progressConfigForCadence", () => {
+  test("normal is the configured cadence, untouched", () => {
+    expect(progressConfigForCadence(CONFIG, "normal")).toBe(CONFIG);
+  });
+
+  test("fewer silences tool activity and stretches the silence tick", () => {
+    const fewer = progressConfigForCadence(CONFIG, "fewer");
+
+    expect(fewer.opsThreshold).toBe(Number.MAX_SAFE_INTEGER);
+    expect(fewer.longOpMs).toBe(Number.MAX_SAFE_INTEGER);
+    expect(fewer.idleIntervalMs).toBe(FEWER_UPDATES_INTERVAL_MS);
+    expect(fewer.maxSilenceMs).toBe(FEWER_UPDATES_INTERVAL_MS);
+    // Narration stays on: a very long silence still proves the call is alive.
+    expect(fewer.enabled).toBe(true);
+  });
+
+  test("fewer never speaks more often than the configured heartbeat", () => {
+    const fewer = progressConfigForCadence(
+      { ...CONFIG, idleIntervalMs: 90_000, maxSilenceMs: 120_000 },
+      "fewer",
+    );
+
+    expect(fewer.idleIntervalMs).toBe(120_000);
+    expect(fewer.maxSilenceMs).toBe(120_000);
+  });
+});
+
+describe("requestedSessionControl", () => {
+  test("the update cadence needs no client declaration", () => {
+    expect(requestedSessionControl("Sure. [UPDATES:FEWER]", [])).toEqual({
+      action: "updates",
+      cadence: "fewer",
+    });
+  });
+
+  test("a client control needs the client's declaration", () => {
+    expect(requestedSessionControl("Bye. [END_CALL]", [])).toBeNull();
+    expect(requestedSessionControl("Bye. [END_CALL]", ["end"])).toEqual({
+      action: "end",
+    });
+  });
+});
+
+describe("sessionControlTeaching", () => {
+  test("teaches the update cadence and only the declared client controls", () => {
+    const teaching = sessionControlTeaching(["mute"], {});
+
+    expect(teaching).toContain("[UPDATES:FEWER]");
+    expect(teaching).toContain("[MUTE]");
+    expect(teaching).not.toContain("[END_CALL]");
+    expect(teaching).toContain("Never emit any other bracketed marker.");
+  });
+
+  test("the front-door leg keeps its verdict tokens", () => {
+    expect(sessionControlTeaching(["end"], { frontDoor: true })).not.toContain(
+      "Never emit any other bracketed marker.",
+    );
+  });
+});