@vellumai/assistant 0.12.1 → 0.12.2-dev.202609162314.7778bc8

package/src/calls/__tests__/voice-progress-cadence.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, test } from "bun:test";
+
+import { VoiceProgressConfigSchema } from "../../config/schemas/voice.js";
+import type { VoiceProgressNarrator } from "../progress-narration.js";
+import {
+  PROGRESS_FALLBACK_PHRASES,
+  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
+} from "../progress-phrases.js";
+import {
+  createProgressCadence,
+  type ProgressCadence,
+  type ProgressCadenceHost,
+} from "../voice-progress-cadence.js";
+
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
+
+async function waitFor(predicate: () => boolean, attempts = 60): Promise<void> {
+  for (let i = 0; i < attempts; i += 1) {
+    if (predicate()) {
+      return;
+    }
+    await sleep(5);
+  }
+  throw new Error("waitFor timed out");
+}
+
+interface Harness {
+  cadence: ProgressCadence;
+  spoken: Array<{ phrase: string; language: string | undefined }>;
+  host: {
+    live: boolean;
+    audioIdle: boolean;
+    tailUntilMs: number;
+    language: string | undefined;
+    deltaEpoch: number;
+    narrationsSpoken: number;
+  };
+}
+
+function harness(opts: {
+  config?: Partial<ReturnType<typeof VoiceProgressConfigSchema.parse>>;
+  narrator?: VoiceProgressNarrator | null;
+  language?: string;
+}): Harness {
+  const state = {
+    live: true,
+    audioIdle: true,
+    tailUntilMs: 0,
+    language: opts.language,
+    deltaEpoch: 0,
+    narrationsSpoken: 0,
+  };
+  const spoken: Harness["spoken"] = [];
+  const host: ProgressCadenceHost = {
+    turnId: "turn-1",
+    launchedAtMs: Date.now(),
+    signal: new AbortController().signal,
+    canNarrate: () => state.live,
+    isAudioIdle: () => state.audioIdle,
+    playbackTailUntilMs: () => state.tailUntilMs,
+    transcriptSoFar: () => "what is on my calendar",
+    language: () => state.language,
+    deltaEpoch: () => state.deltaEpoch,
+    speak: (phrase, language) => {
+      spoken.push({ phrase, language });
+      return true;
+    },
+    onNarrationSpoken: () => {
+      state.narrationsSpoken += 1;
+    },
+  };
+  let counter = 0;
+  const cadence = createProgressCadence({
+    config: VoiceProgressConfigSchema.parse({
+      opsThreshold: 3,
+      idleIntervalMs: 60_000,
+      maxSilenceMs: 60_000,
+      longOpMs: 15_000,
+      minGapMs: 10,
+      generationTimeoutMs: 1_500,
+      ...opts.config,
+    }),
+    narrator:
+      opts.narrator === undefined
+        ? { generateProgressText: async () => "Checking your calendar now." }
+        : opts.narrator,
+    host,
+    nextFallbackPhraseIndex: () => counter++,
+  });
+  return { cadence, spoken, host: state };
+}
+
+describe("createProgressCadence", () => {
+  test("the ops trigger narrates once the threshold of started tools is reached", async () => {
+    const h = harness({});
+    h.cadence.toolStarted("web_search", "t1");
+    h.cadence.toolStarted("web_fetch", "t2");
+    await sleep(15);
+    expect(h.spoken).toEqual([]);
+
+    h.cadence.toolStarted("file_read", "t3");
+    await waitFor(() => h.spoken.length === 1);
+
+    expect(h.spoken[0]).toEqual({
+      phrase: "Checking your calendar now.",
+      language: undefined,
+    });
+    expect(h.cadence.updatesSpoken).toBe(1);
+    expect(h.host.narrationsSpoken).toBe(1);
+    h.cadence.clear();
+  });
+
+  test("a long operation completing narrates on its own beat", async () => {
+    const h = harness({ config: { longOpMs: 20 } });
+    h.cadence.toolStarted("web_search", "t1");
+    await sleep(30);
+    h.cadence.toolFinished({
+      toolName: "web_search",
+      toolUseId: "t1",
+      resultPreview: "three results",
+    });
+    await waitFor(() => h.spoken.length === 1);
+
+    expect(h.cadence.ops[0].completedAtMs).toBeDefined();
+    expect(h.cadence.ops[0].resultPreview).toBe("three results");
+    h.cadence.clear();
+  });
+
+  test("a quick operation completing is only news, not a narration", async () => {
+    const h = harness({});
+    h.cadence.toolStarted("web_search", "t1");
+    h.cadence.toolFinished({ toolName: "web_search", toolUseId: "t1" });
+    await sleep(20);
+
+    expect(h.spoken).toEqual([]);
+    h.cadence.clear();
+  });
+
+  test("a tool_result with no id matches the newest incomplete op of that name", () => {
+    const h = harness({});
+    h.cadence.toolStarted("web_search", "t1");
+    h.cadence.toolStarted("web_search", "t2");
+    h.cadence.toolFinished({ toolName: "web_search", isError: true });
+
+    expect(h.cadence.ops[1].completedAtMs).toBeDefined();
+    expect(h.cadence.ops[1].isError).toBe(true);
+    expect(h.cadence.ops[0].completedAtMs).toBeUndefined();
+    h.cadence.clear();
+  });
+
+  test("the idle tick narrates news since the last update, and the static fallback covers a null generation", async () => {
+    const h = harness({
+      config: { idleIntervalMs: 30, maxSilenceMs: 60_000 },
+      narrator: { generateProgressText: async () => null },
+      language: "es",
+    });
+    h.cadence.arm();
+    await sleep(60);
+    // Nothing observable happened: the tick stays quiet.
+    expect(h.spoken).toEqual([]);
+
+    h.cadence.toolStarted("web_search", "t1");
+    await waitFor(() => h.spoken.length === 1);
+
+    expect(
+      PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE.es.map((p) => p.trim()),
+    ).toContain(h.spoken[0].phrase.trim());
+    // The Spanish table has an entry: the phrase rides the turn's language.
+    expect(h.spoken[0].language).toBeUndefined();
+    h.cadence.clear();
+  });
+
+  test("a static fallback the table lacks in the turn's language is pinned to English", async () => {
+    const h = harness({
+      config: { idleIntervalMs: 30 },
+      narrator: { generateProgressText: async () => null },
+      language: "ko",
+    });
+    h.cadence.arm();
+    h.cadence.toolStarted("web_search", "t1");
+    await waitFor(() => h.spoken.length === 1);
+
+    expect(PROGRESS_FALLBACK_PHRASES).toContain(h.spoken[0].phrase);
+    expect(h.spoken[0].language).toBe("en");
+    h.cadence.clear();
+  });
+
+  test("the heartbeat speaks after maxSilenceMs even with nothing new", async () => {
+    const h = harness({
+      config: { idleIntervalMs: 30, maxSilenceMs: 30 },
+    });
+    h.cadence.arm();
+    await waitFor(() => h.spoken.length === 1);
+    h.cadence.clear();
+  });
+
+  test("nothing speaks while audio is still playing; the countdown restarts once it drains", async () => {
+    const h = harness({ config: { idleIntervalMs: 30, maxSilenceMs: 30 } });
+    h.host.audioIdle = false;
+    h.cadence.arm();
+    await sleep(80);
+    expect(h.spoken).toEqual([]);
+
+    h.host.audioIdle = true;
+    h.cadence.noteAudioSettled();
+    await waitFor(() => h.spoken.length === 1);
+    h.cadence.clear();
+  });
+
+  test("a narration generated while the model resumed speaking is dropped", async () => {
+    let release: () => void = () => {};
+    const h = harness({
+      config: { opsThreshold: 1 },
+      narrator: {
+        generateProgressText: () =>
+          new Promise<string | null>((resolve) => {
+            release = () => resolve("Still on it.");
+          }),
+      },
+    });
+    h.cadence.toolStarted("web_search", "t1");
+    await sleep(10);
+    h.host.deltaEpoch += 1;
+    release();
+    await sleep(20);
+
+    expect(h.spoken).toEqual([]);
+    h.cadence.clear();
+  });
+
+  test("minGapMs spaces narration from another floor holder", async () => {
+    const h = harness({ config: { opsThreshold: 1, minGapMs: 200 } });
+    h.cadence.noteFloorHolder();
+    h.cadence.toolStarted("web_search", "t1");
+    await sleep(30);
+
+    expect(h.spoken).toEqual([]);
+    h.cadence.clear();
+  });
+
+  test("a null narrator or a disabled config never speaks or arms", async () => {
+    const off = harness({ narrator: null, config: { idleIntervalMs: 20 } });
+    off.cadence.arm();
+    off.cadence.toolStarted("a", "1");
+    off.cadence.toolStarted("b", "2");
+    off.cadence.toolStarted("c", "3");
+    const disabled = harness({
+      config: { enabled: false, idleIntervalMs: 20 },
+    });
+    disabled.cadence.arm();
+    disabled.cadence.toolStarted("a", "1");
+    disabled.cadence.toolStarted("b", "2");
+    disabled.cadence.toolStarted("c", "3");
+    await sleep(60);
+
+    expect(off.spoken).toEqual([]);
+    expect(disabled.spoken).toEqual([]);
+  });
+
+  test("clear stops the dead-air timer and a dead turn is never narrated", async () => {
+    const h = harness({ config: { idleIntervalMs: 20, maxSilenceMs: 20 } });
+    h.cadence.arm();
+    h.cadence.clear();
+    await sleep(60);
+    expect(h.spoken).toEqual([]);
+
+    h.host.live = false;
+    h.cadence.toolStarted("a", "1");
+    h.cadence.toolStarted("b", "2");
+    h.cadence.toolStarted("c", "3");
+    await sleep(20);
+    expect(h.spoken).toEqual([]);
+  });
+});

package/src/{__tests__/voice-session-bridge.test.ts → calls/__tests__/voice-session-bridge-turn-flow.test.ts}

@@ -1,13 +1,21 @@
+/**
+ * Tests for `startVoiceTurn`'s turn flow against real persistence: delta and
+ * error forwarding, abort handling, persisted channel metadata, the auto-built
+ * phone control prompt, and the approval-policy split between guardian and
+ * non-guardian callers. The sibling `voice-session-bridge.test.ts` covers the
+ * routing legs, transcript hygiene, tool-event forwarding, and the lock and
+ * teardown races against scripted doubles.
+ */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { AssistantEvent } from "../api/index.js";
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import type { AssistantEvent } from "../../api/index.js";
 import type {
   TurnChannelContext,
   TurnInterfaceContext,
-} from "../channels/types.js";
-import type { Conversation } from "../daemon/conversation.js";
-import { persistUserMessage as persistUserMessageImpl } from "../daemon/conversation-messaging.js";
-import { setConfig } from "./helpers/set-config.js";
+} from "../../channels/types.js";
+import type { Conversation } from "../../daemon/conversation.js";
+import { persistUserMessage as persistUserMessageImpl } from "../../daemon/conversation-messaging.js";
 
 /** Seed the config the voice bridge reads: disclosure copy, plus disabled
  * secret detection and memory so the real persist path stays inert. */
@@ -19,7 +27,7 @@ function seedVoiceConfig(disclosure: { enabled: boolean; text: string }): void {
 
 let voiceConversationFactory: (() => Conversation) | null = null;
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async () => {
     if (!voiceConversationFactory) {
       throw new Error("voiceConversationFactory not set for test");
@@ -28,18 +36,18 @@ mock.module("../daemon/conversation-store.js", () => ({
   },
 }));
 
-import { CALL_OPENING_MARKER } from "../calls/voice-control-protocol.js";
-import { startVoiceTurn } from "../calls/voice-session-bridge.js";
 import {
   createConversation,
   getMessages,
-} from "../persistence/conversation-crud.js";
-import { getDb } from "../persistence/db-connection.js";
-import { initializeDb } from "../persistence/db-init.js";
+} from "../../persistence/conversation-crud.js";
+import { getDb } from "../../persistence/db-connection.js";
+import { initializeDb } from "../../persistence/db-init.js";
 import {
   assistantEventHub,
   broadcastMessage,
-} from "../runtime/assistant-event-hub.js";
+} from "../../runtime/assistant-event-hub.js";
+import { CALL_OPENING_MARKER } from "../voice-control-protocol.js";
+import { startVoiceTurn } from "../voice-session-bridge.js";
 
 await initializeDb();
 

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

@@ -842,6 +842,53 @@ describe("startVoiceTurn triage-and-escalate control prompt", () => {
     expect(installed()).toContain(escalatedContinuationRule());
   });
 
+  test("a direct escalated turn keeps the caller-supplied resume prompt verbatim", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceControlPrompt: LIVE_VOICE_PROMPT,
+      routingLeg: "escalated",
+      directEscalated: true,
+    });
+    expect(installed()).toBe(LIVE_VOICE_PROMPT);
+  });
+
+  test("the auto-built phone prompt carries the front-door rule anchored to the caller's words", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      content: "what time is it",
+      routingLeg: "front-door",
+    });
+    expect(installed()).toContain("<voice_call_control>");
+    expect(installed()).toContain(
+      `13. ${frontDoorDecisionRule({ callerUtterance: "what time is it" })}`,
+    );
+  });
+
+  test("a phone sentinel anchors the front-door rule on its persisted form", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
+    expect(installed()).toContain(
+      frontDoorDecisionRule({
+        callerUtterance: "(call connected — deliver opening greeting)",
+      }),
+    );
+    expect(installed()).not.toContain(JSON.stringify(CALL_OPENING_MARKER));
+  });
+
+  test("the auto-built phone prompt carries the escalated continuation rule", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      routingLeg: "escalated",
+      spokenEscalationBridge: "One moment.",
+    });
+    expect(installed()).toContain(
+      `13. ${escalatedContinuationRule("One moment.")}`,
+    );
+  });
+
   test("leaves a caller-supplied prompt verbatim when no routing leg is set", async () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn({
@@ -860,7 +907,7 @@ describe("default call protocol numbered rules", () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn(makeTurnOptions());
     expect(installed()).toContain(
-      "12. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, use the language the Task context implies, if any; otherwise default to English.",
+      "11. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, use the language the Task context implies, if any; otherwise default to English.",
     );
   });
 
@@ -1930,7 +1977,7 @@ describe("startVoiceTurn tool-event forwarding", () => {
     fakeConversation = fake.conversation;
   }
 
-  test("tool_use_start delivers the tool name, toolUseId, and input", async () => {
+  test("tool_use_start delivers the tool name, input, and active allowlist", async () => {
     makeEventEmittingConversation([
       {
         type: "tool_use_start",
@@ -1939,6 +1986,11 @@ describe("startVoiceTurn tool-event forwarding", () => {
         toolUseId: "toolu-1",
       },
     ]);
+    (
+      fakeConversation as typeof fakeConversation & {
+        allowedToolNames?: Set<string>;
+      }
+    ).allowedToolNames = new Set(["web_search"]);
 
     const starts: Array<{ toolName: string; detail?: unknown }> = [];
     await startVoiceTurn({
@@ -1952,7 +2004,11 @@ describe("startVoiceTurn tool-event forwarding", () => {
     expect(starts).toEqual([
       {
         toolName: "web_search",
-        detail: { toolUseId: "toolu-1", input: { query: "weather" } },
+        detail: {
+          toolUseId: "toolu-1",
+          input: { query: "weather" },
+          allowedToolNames: new Set(["web_search"]),
+        },
       },
     ]);
   });
@@ -2110,6 +2166,68 @@ describe("front-door leg tool suppression", () => {
   });
 });
 
+describe("desktop skill preactivation", () => {
+  async function preactivatedFor(turn: Record<string, unknown>): Promise<{
+    skillIds: string[];
+    proxyInterfaces: unknown[];
+    skillIdsDuringLoop: string[];
+  }> {
+    const skillIds: string[] = [];
+    const proxyInterfaces: unknown[] = [];
+    let skillIdsDuringLoop: string[] = [];
+    const fake = makeFakeConversation({
+      processing: false,
+      runAgentLoop: async () => {
+        skillIdsDuringLoop = [...skillIds];
+      },
+    });
+    Object.assign(fake.conversation, {
+      addPreactivatedSkillId: (id: string) => {
+        skillIds.push(id);
+      },
+      ensureHostProxiesForTurn: (sourceInterface: unknown) => {
+        proxyInterfaces.push(sourceInterface);
+      },
+    });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(undefined, "conv-desktop-skills"),
+      userMessageInterface: "macos",
+      ...turn,
+    });
+    await flushMicrotasks();
+    return { skillIds, proxyInterfaces, skillIdsDuringLoop };
+  }
+
+  test("an escalated leg of a macOS desktop session starts with computer use active", async () => {
+    const result = await preactivatedFor({
+      routingLeg: "escalated",
+      macosDesktopSession: true,
+    });
+
+    expect(result.skillIdsDuringLoop).toContain("computer-use");
+    expect(result.proxyInterfaces).toEqual(["macos"]);
+  });
+
+  test("a session from any other client leaves the desktop skills to be loaded", async () => {
+    const result = await preactivatedFor({ routingLeg: "escalated" });
+
+    expect(result.skillIds).toEqual([]);
+    expect(result.proxyInterfaces).toEqual([]);
+  });
+
+  test("the toolless front-door leg is never preactivated", async () => {
+    const result = await preactivatedFor({
+      routingLeg: "front-door",
+      macosDesktopSession: true,
+    });
+
+    expect(result.skillIds).toEqual([]);
+    expect(result.proxyInterfaces).toEqual([]);
+  });
+});
+
 describe("cutFrontDoorContentAtVerdict", () => {
   test("null when the content carries no verdict token (committed answer)", () => {
     expect(
@@ -2477,6 +2595,25 @@ describe("transcript hygiene (teardown pass)", () => {
     expect(events).toContain("loadFromDb");
   });
 
+  test("a row ending with a session control marker persists with it stripped", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () =>
+      makeRow("Muting you for thirty seconds. [MUTE:30]");
+
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toEqual([
+      {
+        messageId: "assistant-row-1",
+        content: JSON.stringify([
+          { type: "text", text: "Muting you for thirty seconds." },
+        ]),
+      },
+    ]);
+    expect(events).toContain("loadFromDb");
+  });
+
   test("a mid-text [-1] (content, not command) leaves the row untouched", async () => {
     const { events } = makeReservedRowConversation();
     getMessageByIdImpl = () =>

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

@@ -5,6 +5,7 @@ import {
   capEscalationBridge,
   classifyFrontDoorLeading,
   createFrontDoorStreamGate,
+  createFrontDoorVerdictMachine,
   ESCALATE_VERDICT_TOKEN,
   escalatedContinuationRule,
   ESCALATION_CONTINUATION_CONTENT,
@@ -17,6 +18,7 @@ import {
   isEscalationBridgeComplete,
   MAX_ESCALATION_BRIDGE_CHARS,
   needsFallbackBridge,
+  resolveSpokenEscalationBridge,
   spokenBridgeText,
 } from "../voice-triage-escalate.js";
 
@@ -281,6 +283,34 @@ describe("fallbackEscalationBridgeFor", () => {
   });
 });
 
+describe("resolveSpokenEscalationBridge", () => {
+  test("a real capped bridge is spoken as the model's own speech", () => {
+    expect(resolveSpokenEscalationBridge("Let me check that.", "es")).toEqual({
+      spokenBridge: "Let me check that.",
+      usesFallback: false,
+    });
+  });
+
+  test("an empty or too-short bridge falls back to the localized canned phrase, audio-only", () => {
+    expect(resolveSpokenEscalationBridge("", "es")).toEqual({
+      spokenBridge: FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.es,
+      usesFallback: true,
+    });
+    expect(resolveSpokenEscalationBridge("Ok", undefined)).toEqual({
+      spokenBridge: FALLBACK_ESCALATION_BRIDGE,
+      usesFallback: true,
+    });
+  });
+
+  test("a canned phrase the table lacks for the caller's language is English and says so", () => {
+    expect(resolveSpokenEscalationBridge("", "ko")).toEqual({
+      spokenBridge: FALLBACK_ESCALATION_BRIDGE,
+      usesFallback: true,
+      language: "en",
+    });
+  });
+});
+
 describe("capEscalationBridge", () => {
   test("cuts just after the first sentence terminator", () => {
     expect(
@@ -449,6 +479,81 @@ describe("live-voice escalation orchestration (end-to-end — TODO)", () => {
   );
 });
 
+describe("createFrontDoorVerdictMachine", () => {
+  /** Feed `deltas` through a machine and return the step kinds, in order. */
+  function kinds(deltas: string[], holdEnabled = false): string[] {
+    const machine = createFrontDoorVerdictMachine(holdEnabled);
+    return deltas.map((delta) => machine.push(delta).kind);
+  }
+
+  test("stays pending while the lead could still become a token", () => {
+    expect(kinds(["", "[", "1"])).toEqual(["pending", "pending", "pending"]);
+  });
+
+  test("an answer releases the held lead on the transition, then each delta", () => {
+    const machine = createFrontDoorVerdictMachine(false);
+    expect(machine.push("[")).toEqual({ kind: "pending" });
+    expect(machine.push("A] first")).toEqual({
+      kind: "answer",
+      text: "[A] first",
+    });
+    expect(machine.push(", second")).toEqual({
+      kind: "answer",
+      text: ", second",
+    });
+  });
+
+  test("escalate reports the capped bridge on the delta that completes it", () => {
+    const machine = createFrontDoorVerdictMachine(false);
+    expect(machine.push(`${ESCALATE_VERDICT_TOKEN} One `)).toEqual({
+      kind: "escalate",
+      bridge: null,
+    });
+    expect(machine.push("moment")).toEqual({ kind: "bridging" });
+    expect(machine.push(". Extra text past the cap")).toEqual({
+      kind: "bridge",
+      bridge: "One moment.",
+    });
+    expect(machine.push(" more")).toEqual({ kind: "done" });
+  });
+
+  test("a bridge that completes on the verdict delta is reported with it", () => {
+    const machine = createFrontDoorVerdictMachine(false);
+    expect(machine.push(`${ESCALATE_VERDICT_TOKEN} Let me check.`)).toEqual({
+      kind: "escalate",
+      bridge: "Let me check.",
+    });
+  });
+
+  test("finish hands off a bridge that never hit a terminator", () => {
+    const machine = createFrontDoorVerdictMachine(false);
+    machine.push(`${ESCALATE_VERDICT_TOKEN} Give me a second`);
+    expect(machine.finish()).toEqual({
+      kind: "bridge",
+      bridge: "Give me a second",
+    });
+    expect(machine.push("late")).toEqual({ kind: "done" });
+  });
+
+  test("finish on an answer or a pending lead is done, not a bridge", () => {
+    const answering = createFrontDoorVerdictMachine(false);
+    answering.push("Sure.");
+    expect(answering.finish()).toEqual({ kind: "done" });
+    const undecided = createFrontDoorVerdictMachine(false);
+    undecided.push("[");
+    expect(undecided.finish()).toEqual({ kind: "done" });
+  });
+
+  test("hold is a step only when the leg was taught the token", () => {
+    expect(kinds([HOLD_VERDICT_TOKEN], true)).toEqual(["hold"]);
+    expect(kinds([`${HOLD_VERDICT_TOKEN} trailing`], true)).toEqual(["hold"]);
+    expect(kinds([HOLD_VERDICT_TOKEN], false)).toEqual(["answer"]);
+    const held = createFrontDoorVerdictMachine(true);
+    held.push(HOLD_VERDICT_TOKEN);
+    expect(held.push("anything")).toEqual({ kind: "done" });
+  });
+});
+
 describe("createFrontDoorStreamGate", () => {
   /** Feed `deltas` through a gate and return what it released, in order. */
   function release(