@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231715.8da971c

package/src/api/events/tool-result.ts

@@ -54,6 +54,7 @@ export const WebSearchProviderIdSchema = z.enum([
   "fastcrw",
   "searxng",
   "tinyfish",
+  "exa",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
@@ -112,6 +113,16 @@ export const WebFetchMetadataSchema = z.object({
   durationMs: z.number(),
   errorMessage: z.string().optional(),
   mayRequireJavaScript: z.boolean().optional(),
+  /**
+   * The requested `start_index` was past the end of the page, so nothing was
+   * read. Always set, true or false, by an assistant whose metadata carries
+   * every warning a reader acts on (this and `providerWarning` included); a
+   * record without it came from one that predates them, whose remaining
+   * warnings are only in the result text.
+   */
+  startIndexPastEnd: z.boolean().optional(),
+  /** A hosted provider's own warning about the fetch, verbatim. */
+  providerWarning: z.string().optional(),
 });
 
 export type WebFetchMetadata = z.infer<typeof WebFetchMetadataSchema>;

package/src/api/index.ts

@@ -1,5 +1,10 @@
 import { z } from "zod";
 
+export {
+  type AskQuestionInput,
+  AskQuestionInputSchema,
+  type RecordedQuestion,
+} from "./ask-question-tool.js";
 export {
   isComputerUseToolCall,
   resolveComputerUseToolName,
@@ -832,6 +837,8 @@ export {
   FeedItemStatusSchema,
   type FeedItemType,
   FeedItemTypeSchema,
+  type FeedItemUpdate,
+  FeedItemUpdateSchema,
   type FeedItemUrgency,
   FeedItemUrgencySchema,
   GUARDIAN_TERMINAL_REASON_SUPERSEDED,

package/src/api/requests/dictation.ts

@@ -1,8 +1,8 @@
 /**
  * Wire contract for the dictation REST endpoint (`POST /dictation`).
  *
- * The body web/macOS sends when asking the daemon to clean up a raw voice
- * transcript and classify it as dictation vs. action. `context` is its own
+ * The body web/macOS sends to apply explicit dictation replacements, classify
+ * voice input, or edit selected text. `context` is its own
  * named schema/type so consumers (web client) can import `DictationContext`
  * directly instead of inferring it from the generated client.
  *

package/src/api/responses/home.ts

@@ -167,6 +167,28 @@ export type FeedItemGuardianRequest = z.infer<
   typeof FeedItemGuardianRequestSchema
 >;
 
+/**
+ * One background rewrite of a managed skill, as a receipt item lists it.
+ *
+ * A receipt (`detailPanel.kind === "updatesList"`) collapses every skill
+ * update a background pass made within one burst into a single feed item, and
+ * `updates` keeps each rewrite whole: the skill it touched, the pass's own
+ * account of what changed, and the conversation the change came from, when
+ * lineage resolved. The same skill can appear more than once, one entry per
+ * rewrite, in the order the rewrites happened. Clients group on `skillId`
+ * alone, never on `name` or the summary text.
+ */
+export const FeedItemUpdateSchema = z.object({
+  skillId: z.string(),
+  /** The skill's display name at the time of the rewrite. */
+  name: z.string(),
+  /** The pass's own account of what it changed. Plain text, not markdown. */
+  summary: z.string(),
+  /** The conversation the rewrite was distilled from, when it resolved. */
+  conversationId: z.string().optional(),
+});
+export type FeedItemUpdate = z.infer<typeof FeedItemUpdateSchema>;
+
 /**
  * A single item rendered in the Home feed.
  *
@@ -198,6 +220,11 @@ export const FeedItemSchema = z.object({
   // Present only on the canonical "Needs attention" item projecting a
   // guardian request; see FeedItemGuardianRequestSchema.
   guardianRequest: FeedItemGuardianRequestSchema.optional(),
+  // Present only on a skill-update receipt (`detailPanel.kind` is
+  // `updatesList`); see FeedItemUpdateSchema. `summary` still carries the
+  // same content as a plain list, so a client without the panel loses only
+  // the per-skill links.
+  updates: z.array(FeedItemUpdateSchema).optional(),
   category: FeedItemCategorySchema.optional(),
   noteworthy: z.boolean().optional(),
   fromAssistant: z.boolean().optional(),

package/src/avatar/notification-avatar.test.ts

@@ -63,9 +63,6 @@ const TRAITS = { bodyShape: "blob", eyeStyle: "curious", color: "green" };
 const GREEN_DISC = { r: 0xe6, g: 0xf1, b: 0xe7 };
 /** #E9642F mixed 14% into white. */
 const ORANGE_DISC = { r: 0xfc, g: 0xe9, b: 0xe2 };
-/** The neutral disc every accent-less avatar wears. */
-const FALLBACK_DISC = { r: 0xec, g: 0xef, b: 0xea };
-
 /** On the disc and clear of the inset avatar square, which starts at y = 28.16. */
 const DISC_SAMPLE = { x: 128, y: 8 };
 /** Outside the inscribed disc, where the render leaves nothing at all. */
@@ -233,7 +230,7 @@ describe("renderNotificationAvatarPng", () => {
   );
 
   nativeTest(
-    "renders an uploaded image on the neutral disc when it has no accent",
+    "fills the circle with an uploaded image when it has no accent",
     async () => {
       await writeUpload("png", null);
 
@@ -245,7 +242,9 @@ describe("renderNotificationAvatarPng", () => {
       expect(image.height).toBe(256);
       expect(image.at(CORNER.x, CORNER.y).a).toBe(0);
       expect(image.at(DISC_SAMPLE.x, DISC_SAMPLE.y)).toEqual({
-        ...FALLBACK_DISC,
+        r: 0x20,
+        g: 0x60,
+        b: 0xc0,
         a: 255,
       });
       expect(image.at(128, 128)).toEqual({ r: 0x20, g: 0x60, b: 0xc0, a: 255 });
@@ -253,23 +252,34 @@ describe("renderNotificationAvatarPng", () => {
     NATIVE_RENDER_TEST_TIMEOUT_MS,
   );
 
-  nativeTest(
-    "cover-crops a wide upload and clips it to the disc",
-    async () => {
-      // 4:1, so a letterboxing render would leave disc colour above and below
-      // the avatar inside the inset square.
-      await writeUpload("png", null, { width: 256, height: 64 });
-
-      const image = await pixels((await renderNotificationAvatarPng())!);
-      // Inside the inset square (which starts at 28.16) near its top edge:
-      // filled by a cover-crop, disc colour by a letterbox.
-      expect(image.at(128, 35)).toEqual({ r: 0x20, g: 0x60, b: 0xc0, a: 255 });
-      // Inside the inset square but outside the disc, so only the clip can
-      // keep the avatar out of it.
-      expect(image.at(30, 30).a).toBe(0);
-    },
-    NATIVE_RENDER_TEST_TIMEOUT_MS,
-  );
+  for (const [shape, width, height] of [
+    ["landscape", 256, 64],
+    ["portrait", 64, 256],
+  ] as const) {
+    nativeTest(
+      `cover-crops a ${shape} upload to the full disc`,
+      async () => {
+        await writeUpload("png", null, { width, height });
+
+        const image = await pixels((await renderNotificationAvatarPng())!);
+        for (const [x, y] of [
+          [128, 8],
+          [8, 128],
+          [128, 248],
+          [248, 128],
+        ]) {
+          expect(image.at(x!, y!)).toEqual({
+            r: 0x20,
+            g: 0x60,
+            b: 0xc0,
+            a: 255,
+          });
+        }
+        expect(image.at(30, 30).a).toBe(0);
+      },
+      NATIVE_RENDER_TEST_TIMEOUT_MS,
+    );
+  }
 
   nativeTest(
     "transcodes a WebP upload, which resvg cannot decode on its own",
@@ -281,20 +291,18 @@ describe("renderNotificationAvatarPng", () => {
 
       const image = await pixels(png!);
       expect(image.at(CORNER.x, CORNER.y).a).toBe(0);
-      expect(image.at(DISC_SAMPLE.x, DISC_SAMPLE.y)).toEqual({
-        ...FALLBACK_DISC,
-        a: 255,
-      });
       // WebP is lossy, so the transcode moves the flat fill by a channel step
       // or two; what matters is that the avatar is drawn at all.
-      const centre = image.at(128, 128);
-      expect(centre.a).toBe(255);
-      for (const [actual, expected] of [
-        [centre.r, 0x20],
-        [centre.g, 0x60],
-        [centre.b, 0xc0],
-      ]) {
-        expect(Math.abs(actual! - expected!)).toBeLessThanOrEqual(4);
+      for (const point of [{ x: 128, y: 128 }, DISC_SAMPLE]) {
+        const pixel = image.at(point.x, point.y);
+        expect(pixel.a).toBe(255);
+        for (const [actual, expected] of [
+          [pixel.r, 0x20],
+          [pixel.g, 0x60],
+          [pixel.b, 0xc0],
+        ]) {
+          expect(Math.abs(actual! - expected!)).toBeLessThanOrEqual(4);
+        }
       }
     },
     NATIVE_RENDER_TEST_TIMEOUT_MS,

package/src/avatar/notification-avatar.ts

@@ -222,6 +222,7 @@ export async function renderNotificationAvatarPng(
     const Resvg = getResvg();
     const resvg = new Resvg(
       notificationAvatarSvg({
+        kind: state.kind,
         innerPngBase64: source.bytes.toString("base64"),
         innerMediaType: source.mediaType,
         accentHex: resolveNotificationAccentHex(state),

package/src/calls/__tests__/call-controller.test.ts

@@ -4355,6 +4355,24 @@ describe("call-controller", () => {
       controller.destroy();
     });
 
+    test("a terminal verdict hands off without repeating the streamed bridge", async () => {
+      const bridge = "Let me check that.";
+      const { calls } = scriptLegs([
+        [bridge, " [", "ESCALATE", "]"],
+        ["The answer is 42."],
+      ]);
+      const { relay, controller } = setupController();
+
+      await controller.handleCallerUtterance("What is six times seven?");
+
+      expect(calls).toHaveLength(2);
+      expect(calls[1].routingLeg).toBe("escalated");
+      expect(calls[1].spokenEscalationBridge).toBe(bridge);
+      expect(spokenText(relay)).toBe(`${bridge} The answer is 42.`);
+      expect(relay.sentTokens.filter((t) => t.last)).toHaveLength(1);
+      controller.destroy();
+    });
+
     test("a bare escalate verdict speaks the canned bridge, audio-only", async () => {
       const { calls } = scriptLegs([["[1]"], ["Forty-two."]]);
       const { session, relay, controller } = setupController();

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

@@ -17,10 +17,13 @@ import {
 describe("front-door verdict tokens", () => {
   test("token constants are the expected bracketed forms", () => {
     expect(HOLD_VERDICT_TOKEN).toBe("[0]");
-    expect(ESCALATE_VERDICT_TOKEN).toBe("[1]");
+    expect(ESCALATE_VERDICT_TOKEN).toBe("[ESCALATE]");
   });
 
   test("stripInternalSpeechMarkers removes both tokens so they are never spoken", () => {
+    expect(stripInternalSpeechMarkers("[ESCALATE] Let me check.").trim()).toBe(
+      "Let me check.",
+    );
     expect(
       stripInternalSpeechMarkers("[1] Let me think about that.").trim(),
     ).toBe("Let me think about that.");
@@ -59,6 +62,7 @@ describe("isIncompleteControlMarkerTail", () => {
       "[-",
       "[-1",
       "[END_CAL",
+      "[ESCALAT",
       "[TASK:ST",
       "[ASK_GUARDIAN_APPRO",
     ]) {
@@ -70,6 +74,7 @@ describe("isIncompleteControlMarkerTail", () => {
     for (const tail of [
       "[-1]",
       "[END_CALL]",
+      "[ESCALATE]",
       TASK_STOP_MARKER,
       "[0] answer",
       "[-1] look here",

package/src/calls/__tests__/voice-leg-coordinator.test.ts

@@ -148,6 +148,48 @@ describe("createFrontDoorLegCoordinator", () => {
     expect(recorded.escalated.length).toBe(1);
   });
 
+  test("a terminal verdict hands off once with the already released speech", () => {
+    const { coordinator, recorded } = harness();
+    const bridge = "I will highlight the Rotate control on your screen.";
+    coordinator.push(bridge);
+    expect(recorded.answers).toEqual([bridge]);
+    coordinator.push(" [");
+    coordinator.push("ESCALATE]");
+    expect(coordinator.handedOff).toBe(false);
+
+    expect(coordinator.complete()).toBe(true);
+    expect(recorded.bridges).toEqual([
+      { spokenBridge: bridge, usesFallback: false, alreadyReleased: true },
+    ]);
+    expect(recorded.escalated).toEqual([escalatedLegFor(bridge)]);
+    expect(recorded.events).not.toContain("overrule");
+    coordinator.complete();
+    coordinator.push("late text");
+    expect(recorded.escalated).toHaveLength(1);
+  });
+
+  test("a cancelled answer with a terminal verdict never hands off", () => {
+    let live = true;
+    const { coordinator, recorded } = harness({ live: () => live });
+    coordinator.push("I will highlight it. [ESCALATE]");
+    live = false;
+    expect(coordinator.complete()).toBe(false);
+    expect(recorded.bridges).toEqual([]);
+    expect(recorded.escalated).toEqual([]);
+  });
+
+  test.each(["Select option [1]", "The source is listed as [1]"])(
+    "a numbered reference does not start another leg: %s",
+    (answer) => {
+      const { coordinator, recorded } = harness();
+      coordinator.push(answer);
+      expect(coordinator.complete()).toBe(false);
+      expect(recorded.answers).toEqual([answer]);
+      expect(recorded.bridges).toEqual([]);
+      expect(recorded.escalated).toEqual([]);
+    },
+  );
+
   test("a leg that stops mid-bridge hands off on completion with the canned bridge", () => {
     const { coordinator, recorded } = harness({ language: "es" });
     coordinator.push("[1]");

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

@@ -143,6 +143,10 @@ mock.module("../../persistence/conversation-crud.js", () => ({
   recordConversationPersistedSeq: () => {},
 }));
 
+import {
+  clearHubClients,
+  registerHubClient,
+} from "../../__tests__/helpers/hub-clients.js";
 import { setConfig } from "../../__tests__/helpers/set-config.js";
 import type { PreparedModelCall } from "../../agent/loop.js";
 import { selectWinningProfile } from "../../config/llm-resolver.js";
@@ -2326,21 +2330,30 @@ describe("front-door leg tool suppression", () => {
 });
 
 describe("desktop skill preactivation", () => {
+  afterEach(() => clearHubClients(assistantEventHub));
+
   async function preactivatedFor(turn: Record<string, unknown>): Promise<{
     skillIds: string[];
     proxyInterfaces: unknown[];
     skillIdsDuringLoop: string[];
+    promptDuringLoop: string | null;
   }> {
     const skillIds: string[] = [];
     const proxyInterfaces: unknown[] = [];
     let skillIdsDuringLoop: string[] = [];
+    let prompt: string | null = null;
+    let promptDuringLoop: string | null = null;
     const fake = makeFakeConversation({
       processing: false,
       runAgentLoop: async () => {
         skillIdsDuringLoop = [...skillIds];
+        promptDuringLoop = prompt;
       },
     });
     Object.assign(fake.conversation, {
+      setVoiceCallControlPrompt: (value: string | null) => {
+        prompt = value;
+      },
       addPreactivatedSkillId: (id: string) => {
         skillIds.push(id);
       },
@@ -2356,9 +2369,58 @@ describe("desktop skill preactivation", () => {
       ...turn,
     });
     await flushMicrotasks();
-    return { skillIds, proxyInterfaces, skillIdsDuringLoop };
+    return { skillIds, proxyInterfaces, skillIdsDuringLoop, promptDuringLoop };
   }
 
+  test("a shared-screen turn receives the annotation instructions and schemas before inference", async () => {
+    registerHubClient({
+      hub: assistantEventHub,
+      clientId: "annotation-client",
+      interfaceId: "macos",
+      actorPrincipalId: "user-123",
+      capabilities: ["host_cu", "host_cu_annotate"],
+    });
+    const result = await preactivatedFor({
+      routingLeg: "escalated",
+      macosDesktopSession: true,
+      screenSharing: true,
+      actorPrincipalId: "user-123",
+    });
+    expect(result.skillIdsDuringLoop).toContain("screen-annotation");
+    expect(result.promptDuringLoop).toContain("ID: screen-annotation");
+    expect(result.promptDuringLoop).toContain("Name the thing.");
+    expect(result.promptDuringLoop).toContain("screen_point_at");
+    expect(result.promptDuringLoop).toContain("screen_clear_marks");
+    expect(result.promptDuringLoop).toContain('"target"');
+    expect(result.promptDuringLoop).toContain("skill_execute");
+  });
+
+  test.each([
+    { screenSharing: false },
+    { actorPrincipalId: "other-user" },
+    { routingLeg: "front-door" },
+    { macosDesktopSession: false },
+  ])(
+    "does not preload annotation for an ineligible turn: %j",
+    async (override) => {
+      registerHubClient({
+        hub: assistantEventHub,
+        clientId: "annotation-client",
+        interfaceId: "macos",
+        actorPrincipalId: "user-123",
+        capabilities: ["host_cu", "host_cu_annotate"],
+      });
+      const result = await preactivatedFor({
+        routingLeg: "escalated",
+        macosDesktopSession: true,
+        screenSharing: true,
+        actorPrincipalId: "user-123",
+        ...override,
+      });
+      expect(result.promptDuringLoop).not.toContain("ID: screen-annotation");
+    },
+  );
+
   test("an escalated leg of a macOS desktop session starts with computer use active", async () => {
     const result = await preactivatedFor({
       routingLeg: "escalated",
@@ -2423,6 +2485,18 @@ describe("cutFrontDoorContentAtVerdict", () => {
     expect(cut?.spokenText).toBe("");
   });
 
+  test("a terminal verdict split across blocks preserves all released speech", () => {
+    const bridge = "Let me check. I will highlight the Rotate control.";
+    const cut = cutFrontDoorContentAtVerdict([
+      { type: "text", text: `${bridge} [` },
+      { type: "text", text: "ESCALATE] " },
+    ]);
+    expect(cut).toEqual({
+      blocks: [{ type: "text", text: bridge }],
+      spokenText: bridge,
+    });
+  });
+
   test("stray verdict tokens inside an answer are stripped, not treated as escalation", () => {
     const cut = cutFrontDoorContentAtVerdict([
       { type: "text", text: "It is Tuesday [0] indeed." },
@@ -2449,7 +2523,7 @@ describe("front-door hub stream gate", () => {
    * `deltas` in order, then ends the leg with `finalEvent`.
    */
   function makeStreamingConversation(
-    deltas: string[],
+    deltas: readonly string[],
     finalEvent:
       | "message_complete"
       | "generation_cancelled" = "message_complete",
@@ -2533,6 +2607,22 @@ describe("front-door hub stream gate", () => {
     expect(texts.join("")).toBe("It is Tuesday, and it is sunny.");
   });
 
+  test("a terminal escalation never broadcasts marker fragments", async () => {
+    makeStreamingConversation([
+      "I will highlight it.",
+      " [",
+      "ESC",
+      "ALATE",
+      "]",
+    ]);
+
+    const texts = await collectBroadcastText(() =>
+      startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" }),
+    );
+
+    expect(texts).toEqual(["I will highlight it.", " "]);
+  });
+
   test("an answer waits on the escalation judge before reaching the hub", async () => {
     let openGate!: () => void;
     judgeEscalationGate = new Promise<void>((resolve) => {
@@ -2556,9 +2646,12 @@ describe("front-door hub stream gate", () => {
     }
   });
 
-  test("an overruled answer never reaches the hub", async () => {
+  test.each([
+    { deltas: ["Yeah okay, ", "I'll do it."] },
+    { deltas: ["[ASK_GUARDIAN:"] },
+  ])("an overruled answer never reaches the hub: %j", async ({ deltas }) => {
     judgeEscalationVerdict = true;
-    makeStreamingConversation(["Yeah okay, ", "I'll do it."]);
+    makeStreamingConversation(deltas);
 
     const texts = await collectBroadcastText(async () => {
       const handle = await startVoiceTurn({

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

@@ -393,13 +393,14 @@ describe("spokenBridgeText", () => {
     expect(spokenBridgeText(ESCALATE_VERDICT_TOKEN)).toBe("");
   });
 
-  test("is empty when the output does not lead with the verdict (an answer)", () => {
-    // A stray token later in an answer is not an escalation under the
-    // verdict-first protocol.
+  test("is empty for an answer with no leading or terminal verdict", () => {
     expect(spokenBridgeText("It is Tuesday.")).toBe("");
-    expect(spokenBridgeText(`Half an answer ${ESCALATE_VERDICT_TOKEN}`)).toBe(
-      "",
-    );
+    expect(spokenBridgeText("The token [1] is reserved.")).toBe("");
+  });
+
+  test("a terminal verdict preserves every sentence already released", () => {
+    const bridge = "Let me check. I will highlight the control.";
+    expect(spokenBridgeText(`${bridge} [ESCALATE]`)).toBe(bridge);
   });
 });
 
@@ -419,7 +420,7 @@ describe("needsFallbackBridge", () => {
 
 describe("classifyFrontDoorLeading", () => {
   test("pending while the stream could still become a verdict token", () => {
-    for (const leading of ["", "[", "[1"]) {
+    for (const leading of ["", "[", "[1", "[E", "[ESCALATE"]) {
       expect(classifyFrontDoorLeading(leading, false)).toBe("pending");
     }
     expect(classifyFrontDoorLeading("[0", true)).toBe("pending");
@@ -435,6 +436,10 @@ describe("classifyFrontDoorLeading", () => {
   });
 
   test("escalate on the leading escalate token", () => {
+    expect(classifyFrontDoorLeading("[ESCALATE]", false)).toBe("escalate");
+    expect(classifyFrontDoorLeading("[ESCALATE] Let me check.", true)).toBe(
+      "escalate",
+    );
     expect(classifyFrontDoorLeading("[1]", false)).toBe("escalate");
     expect(classifyFrontDoorLeading("[1] Let me check.", true)).toBe(
       "escalate",
@@ -544,6 +549,38 @@ describe("createFrontDoorVerdictMachine", () => {
     expect(undecided.finish()).toEqual({ kind: "done" });
   });
 
+  test("a terminal verdict recovers at completion across every delta boundary", () => {
+    const bridge = "I will highlight the Rotate control on your screen.";
+    const text = `${bridge} [ESCALATE] \n`;
+    for (let split = 1; split < text.length; split++) {
+      const machine = createFrontDoorVerdictMachine(false);
+      expect(machine.push(text.slice(0, split)).kind).toBe("answer");
+      expect(machine.push(text.slice(split)).kind).toBe("answer");
+      expect(machine.finish()).toEqual({ kind: "terminal-escalate", bridge });
+      expect(machine.finish()).toEqual({ kind: "done" });
+      expect(machine.push("late")).toEqual({ kind: "done" });
+    }
+  });
+
+  test.each([
+    "Select option [1]",
+    "The source is listed as [1]",
+    "The source supports this statement. [1]",
+    "I will highlight it. [1]",
+    "The token [ESCALATE] is reserved.",
+    "I will highlight it. [ESCALATE",
+    "The token is `[ESCALATE]`",
+    "The token [1] is reserved.",
+    "I will highlight it. [1",
+    "I will highlight it.[1]",
+    "The token is `[1]`",
+    "I will highlight it. [0]",
+  ])("does not recover a nonterminal or incomplete verdict: %s", (text) => {
+    const machine = createFrontDoorVerdictMachine(false);
+    machine.push(text);
+    expect(machine.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"]);
@@ -627,15 +664,36 @@ describe("createFrontDoorStreamGate", () => {
     expect(release(["[1] Let me check"], { finish: false })).toEqual([]);
   });
 
+  test("recovering a terminal verdict never releases the answer twice", () => {
+    const deltas = ["I will highlight it.", " [", "ESCALATE", "]"];
+    expect(release(deltas)).toEqual(["I will highlight it.", " "]);
+  });
+
+  test("terminal verdict fragments never escape at any delta boundary", () => {
+    const text = "I will highlight it. [ESCALATE]";
+    for (let split = 1; split < text.length; split++) {
+      expect(release([text.slice(0, split), text.slice(split)]).join("")).toBe(
+        "I will highlight it. ",
+      );
+    }
+  });
+
+  test("an incomplete marker is flushed only on normal completion", () => {
+    expect(release(["An opening bracket ["], { finish: false })).toEqual([
+      "An opening bracket ",
+    ]);
+    expect(release(["An opening bracket ["]).join("")).toBe(
+      "An opening bracket [",
+    );
+  });
+
   test("a hold verdict releases nothing", () => {
     expect(release([HOLD_VERDICT_TOKEN], { holdEnabled: true })).toEqual([]);
   });
 
-  test("the hold token is ordinary text on a leg that was never taught it", () => {
-    // A non-speculative leg's prompt has no hold branch, so its output must
-    // not be swallowed by a token it could only have parroted.
+  test("the hold token is stripped without discarding a non-speculative answer", () => {
     expect(release([`${HOLD_VERDICT_TOKEN} is the index.`])).toEqual([
-      `${HOLD_VERDICT_TOKEN} is the index.`,
+      " is the index.",
     ]);
   });
 

package/src/calls/call-controller.ts

@@ -1158,7 +1158,9 @@ export class CallController {
         speakFixedPhrase(bridge.spokenBridge, bridge.language);
         return;
       }
-      fullResponseText += `${bridge.spokenBridge} `;
+      if (!bridge.alreadyReleased) {
+        fullResponseText += `${bridge.spokenBridge} `;
+      }
       flushSafeText(fullResponseText, { force: true });
       // Force-synthesize the bridge now. On the synthesized-TTS path text is
       // held in pendingSynthText until a sentence boundary, so an

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

@@ -28,7 +28,12 @@ export const TASK_UPDATE_SILENT_MARKER = "[TASK_UPDATE:SILENT]";
  * markers they are swallowed before reaching TTS — never spoken aloud.
  */
 export const HOLD_VERDICT_TOKEN = "[0]";
-export const ESCALATE_VERDICT_TOKEN = "[1]";
+export const ESCALATE_VERDICT_TOKEN = "[ESCALATE]";
+const LEGACY_ESCALATE_VERDICT_TOKEN = "[1]";
+export const ESCALATE_VERDICT_TOKENS = [
+  ESCALATE_VERDICT_TOKEN,
+  LEGACY_ESCALATE_VERDICT_TOKEN,
+] as const;
 
 /**
  * Room-minimize token, kept in the marker table so it is stripped from
@@ -93,7 +98,6 @@ const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
 const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
 const TASK_STOP_MARKER_REGEX = /\[TASK:STOP\]/g;
 const HOLD_VERDICT_TOKEN_REGEX = /\[0\]/g;
-const ESCALATE_VERDICT_TOKEN_REGEX = /\[1\]/g;
 const MINIMIZE_ROOM_MARKER_REGEX = /\[-1\]/g;
 const MUTE_MARKER_REGEX = /\[MUTE(?::\s*[^\]]*)?\]/g;
 const UPDATES_MARKER_REGEX = /\[UPDATES:\s*[^\]]*\]/g;
@@ -223,7 +227,8 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(TASK_STOP_MARKER_REGEX, "")
     .replaceAll(TASK_UPDATE_SILENT_MARKER, "")
     .replace(HOLD_VERDICT_TOKEN_REGEX, "")
-    .replace(ESCALATE_VERDICT_TOKEN_REGEX, "")
+    .replaceAll(ESCALATE_VERDICT_TOKEN, "")
+    .replaceAll(LEGACY_ESCALATE_VERDICT_TOKEN, "")
     .replace(MINIMIZE_ROOM_MARKER_REGEX, "")
     .replace(MUTE_MARKER_REGEX, "")
     .replace(UPDATES_MARKER_REGEX, "")
@@ -253,7 +258,7 @@ const CONTROL_MARKER_STRINGS = [
   TASK_STOP_MARKER,
   TASK_UPDATE_SILENT_MARKER,
   "[0]",
-  "[1]",
+  ...ESCALATE_VERDICT_TOKENS,
   "[-1]",
   MUTE_MARKER,
   MUTE_MARKER_PREFIX,