@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/runtime/slack-reply-session.ts

@@ -1,6 +1,10 @@
-import type { SlackStreamOp, SlackStreamTask } from "@vellumai/gateway-client";
+import type { StreamPlan } from "@vellumai/gateway-client";
 
-import type { AssistantEvent } from "../api/index.js";
+import type {
+  AssistantEvent,
+  ToolResultEvent,
+  ToolUseStartEvent,
+} from "../api/index.js";
 import {
   extractThreadTsFromCallbackUrl,
   isSlackDeliveryCallbackUrl,
@@ -12,19 +16,16 @@ import {
 } from "../daemon/assistant-attachments.js";
 import { sendChannelStreamOp } from "../messaging/providers/index.js";
 import { SLACK_STREAM_MARKDOWN_LIMIT } from "../messaging/providers/slack/api.js";
-import { renderSlackBlocks } from "../messaging/providers/slack/render.js";
 import { getLogger } from "../util/logger.js";
 import { needsBoundarySpace } from "../util/text-spacing.js";
 import {
   hasDeliverableAssistantText,
   NO_RESPONSE_INLINE_RE,
 } from "./no-response.js";
-import type { TaskProgressData } from "./slack-task-progress.js";
 import {
-  getTaskProgressDataFromSurfaceData,
+  getTaskProgressDataFromToolInput,
   mergeTaskProgressData,
-  toSlackStreamTasks,
-} from "./slack-task-progress.js";
+} from "./task-progress.js";
 
 const log = getLogger("slack-reply-session");
 
@@ -155,8 +156,7 @@ export function createSlackReplySession(params: {
   // `renderHistoryContent`'s `joinWithSpacing` on the durable delivery path).
   let pendingSegmentBoundary = false;
 
-  const taskProgressBySurfaceId = new Map<string, TaskProgressData>();
-  let activeProgress: TaskProgressData | undefined;
+  let activeProgress: StreamPlan | undefined;
   // Fingerprint of the plan state last delivered to Slack, so progress that
   // advances without new body text still flushes as a task-only append.
   let deliveredProgressKey: string | undefined;
@@ -187,25 +187,8 @@ export function createSlackReplySession(params: {
     return stripVellumLinks(stable).replace(NO_RESPONSE_INLINE_RE, "");
   };
 
-  const planTasks = (): SlackStreamTask[] | undefined =>
-    activeProgress ? toSlackStreamTasks(activeProgress) : undefined;
-
-  const progressKey = (
-    title: string | undefined,
-    tasks: SlackStreamTask[] | undefined,
-  ): string | undefined =>
-    tasks ? JSON.stringify({ title, tasks }) : undefined;
-
-  // Typed from the stream operation these are passed to, so the element type
-  // follows that contract rather than drifting from it.
-  const imageBlocks = (
-    text: string,
-  ): Extract<SlackStreamOp, { action: "stop" }>["blocks"] => {
-    const blocks = renderSlackBlocks(text)?.filter(
-      (block) => block.type === "image",
-    );
-    return blocks && blocks.length > 0 ? blocks : undefined;
-  };
+  const progressKey = (plan: StreamPlan | undefined): string | undefined =>
+    plan ? JSON.stringify(plan) : undefined;
 
   const enqueue = (op: () => Promise<void>): void => {
     opChain = opChain.catch(() => undefined).then(op);
@@ -218,28 +201,28 @@ export function createSlackReplySession(params: {
         return;
       }
       const firstChunk = clean.slice(0, SLACK_STREAM_MARKDOWN_LIMIT);
-      const title = activeProgress?.title;
-      const tasks = planTasks();
+      const plan = activeProgress;
       try {
         const result = await sendChannelStreamOp(replyCallbackUrl, chatId, {
           action: "start",
-          threadTs,
-          markdownText: firstChunk,
-          // The task display mode is fixed for the stream's lifetime at
-          // start, while a `task_progress` surface usually appears only
-          // after the first text flush has opened the stream. Plan mode
-          // only affects how task chunks render, so a stream that never
-          // carries tasks still reads as a plain message.
-          taskDisplayMode: "plan" as const,
-          ...(title ? { planTitle: title } : {}),
-          ...(tasks ? { tasks } : {}),
-          ...(recipientUserId ? { recipientUserId } : {}),
-          ...(recipientTeamId ? { recipientTeamId } : {}),
+          anchorMessageId: threadTs,
+          text: clean,
+          appended: firstChunk,
+          ...(plan ? { plan } : {}),
+          ...(recipientUserId
+            ? {
+                audience: {
+                  kind: "oneReader" as const,
+                  userId: recipientUserId,
+                  ...(recipientTeamId ? { userOrgId: recipientTeamId } : {}),
+                },
+              }
+            : {}),
         });
         if (result.ok && result.ts) {
           streamTs = result.ts;
           confirmedLength = firstChunk.length;
-          deliveredProgressKey = progressKey(title, tasks);
+          deliveredProgressKey = progressKey(plan);
           state = "streaming";
           // The stream is already open on Slack's side, so an `onStreamOpen`
           // failure must not downgrade to fallback and repost the visible
@@ -270,9 +253,8 @@ export function createSlackReplySession(params: {
         return;
       }
       const clean = streamableText();
-      const title = activeProgress?.title;
-      const tasks = planTasks();
-      const key = progressKey(title, tasks);
+      const plan = activeProgress;
+      const key = progressKey(plan);
       // `chat.appendStream` caps `markdown_text` per call, so a delta wider
       // than the limit drains across successive append calls. Each append
       // carries the current task state, advancing the plan alongside text.
@@ -284,10 +266,10 @@ export function createSlackReplySession(params: {
         try {
           await sendChannelStreamOp(replyCallbackUrl, chatId, {
             action: "append",
-            streamTs,
-            markdownText: chunk,
-            ...(title ? { planTitle: title } : {}),
-            ...(tasks ? { tasks } : {}),
+            streamId: streamTs,
+            text: clean,
+            appended: chunk,
+            ...(plan ? { plan } : {}),
           });
           confirmedLength += chunk.length;
           deliveredProgressKey = key ?? deliveredProgressKey;
@@ -305,13 +287,13 @@ export function createSlackReplySession(params: {
       // A failure disables further task-only appends for the session; the
       // unchanged fingerprint leaves the update pending, so it rides the
       // next text append and `stopStream` carries the final state.
-      if (!taskOnlyAppendsDisabled && tasks && key !== deliveredProgressKey) {
+      if (!taskOnlyAppendsDisabled && plan && key !== deliveredProgressKey) {
         try {
           await sendChannelStreamOp(replyCallbackUrl, chatId, {
             action: "append",
-            streamTs,
-            ...(title ? { planTitle: title } : {}),
-            tasks,
+            streamId: streamTs,
+            text: clean,
+            plan,
           });
           deliveredProgressKey = key;
         } catch (err) {
@@ -363,24 +345,68 @@ export function createSlackReplySession(params: {
     }
   };
 
-  const observeTaskProgress = (msg: AssistantEvent): void => {
-    if (msg.type === "ui_surface_show") {
-      const progress = getTaskProgressDataFromSurfaceData(msg.data);
-      if (!progress) {
-        return;
-      }
-      taskProgressBySurfaceId.set(msg.surfaceId, progress);
-    } else if (msg.type === "ui_surface_update") {
-      const existing = taskProgressBySurfaceId.get(msg.surfaceId);
-      const progress = mergeTaskProgressData(existing, msg.data);
-      if (!progress) {
-        return;
-      }
-      taskProgressBySurfaceId.set(msg.surfaceId, progress);
-    } else {
+  /**
+   * The plan tool calls this turn has made, awaiting their results.
+   *
+   * `ui_show` and `ui_update` are tools the model reaches for, so a plan is
+   * turn output and arrives on this session's own stream. The daemon also
+   * publishes `ui_surface_show`, but that goes to the conversation sink, which
+   * no channel consumes.
+   *
+   * Held rather than applied on sight, because a `tool_use_start` is an
+   * intention: the surface tool rejects a stale `surface_id` or a malformed
+   * payload, and showing a plan the canonical surface refused is worse than
+   * showing none. An update is also merged at result time so it composes onto
+   * the plan actually in effect rather than the one in effect when the call
+   * began.
+   *
+   * `ui_show` carries no surface id in its input, since the id is minted when
+   * the tool runs, so a later `ui_update` cannot be matched to the card it
+   * targets. One plan per turn is tracked instead, which is what a map keyed by
+   * surface id collapsed to in practice: whichever entry was touched last was
+   * the one rendered.
+   */
+  const pendingPlanCalls = new Map<
+    string,
+    {
+      readonly kind: "show" | "update";
+      readonly input: Record<string, unknown>;
+    }
+  >();
+
+  const observePlanToolStart = (msg: ToolUseStartEvent): void => {
+    const kind =
+      msg.toolName === "ui_show"
+        ? "show"
+        : msg.toolName === "ui_update"
+          ? "update"
+          : undefined;
+    if (!kind || !msg.toolUseId) {
+      return;
+    }
+    pendingPlanCalls.set(msg.toolUseId, { kind, input: msg.input });
+  };
+
+  const observePlanToolResult = (msg: ToolResultEvent): void => {
+    if (!msg.toolUseId) {
+      return;
+    }
+    const pending = pendingPlanCalls.get(msg.toolUseId);
+    if (!pending) {
+      return;
+    }
+    pendingPlanCalls.delete(msg.toolUseId);
+    if (msg.isError === true) {
+      return;
+    }
+    const progress =
+      pending.kind === "show"
+        ? getTaskProgressDataFromToolInput(pending.input)
+        : mergeTaskProgressData(activeProgress, pending.input.data);
+    if (!progress) {
       return;
     }
-    activeProgress = taskProgressBySurfaceId.get(msg.surfaceId);
+    activeProgress = progress;
     scheduleFlush();
   };
 
@@ -390,9 +416,15 @@ export function createSlackReplySession(params: {
         return;
       }
 
-      if (msg.type === "ui_surface_show" || msg.type === "ui_surface_update") {
-        observeTaskProgress(msg);
-        return;
+      if (msg.type === "tool_use_start") {
+        observePlanToolStart(msg);
+      }
+      // guard:allow-tool-result-only. This reads `AssistantEvent`, not the
+      // provider content blocks the guard protects: `web_search_tool_result`
+      // is a block type in conversation history and never an event, so no
+      // result can be dropped by omitting it.
+      if (msg.type === "tool_result") {
+        observePlanToolResult(msg);
       }
       if (msg.type === "assistant_text_delta") {
         if (pendingSegmentBoundary && msg.text.length > 0) {
@@ -433,17 +465,17 @@ export function createSlackReplySession(params: {
         }
         const clean = cleanedText();
         const remaining = clean.slice(confirmedLength);
-        const blocks = imageBlocks(clean);
-        const title = activeProgress?.title;
-        const tasks = planTasks();
+        const plan = activeProgress;
         try {
           await sendChannelStreamOp(replyCallbackUrl, chatId, {
             action: "stop",
-            streamTs,
-            ...(remaining.length > 0 ? { markdownText: remaining } : {}),
-            ...(blocks ? { blocks } : {}),
-            ...(title ? { planTitle: title } : {}),
-            ...(tasks ? { tasks } : {}),
+            streamId: streamTs,
+            // The whole reply, not the remainder. A channel that finalizes its
+            // stream in place appends `appended`; one whose preview evaporates
+            // needs this to send the message that stays.
+            text: clean,
+            ...(remaining.length > 0 ? { appended: remaining } : {}),
+            ...(plan ? { plan } : {}),
           });
           confirmedLength = clean.length;
         } catch (err) {

package/src/runtime/{slack-task-progress.test.ts → task-progress.test.ts}

@@ -3,8 +3,7 @@ import { describe, expect, test } from "bun:test";
 import {
   getTaskProgressDataFromSurfaceData,
   mergeTaskProgressData,
-  toSlackStreamTasks,
-} from "./slack-task-progress.js";
+} from "./task-progress.js";
 
 describe("getTaskProgressDataFromSurfaceData", () => {
   test("reads title, steps, and step details from a task_progress surface", () => {
@@ -99,29 +98,3 @@ describe("mergeTaskProgressData", () => {
     });
   });
 });
-
-describe("toSlackStreamTasks", () => {
-  test("maps steps onto Slack task cards with stable ids and details", () => {
-    expect(
-      toSlackStreamTasks({
-        title: "Quick Briefing",
-        steps: [
-          {
-            label: "Check weather",
-            status: "completed",
-            detail: "Forecast fetched",
-          },
-          { label: "Summarize", status: "failed" },
-        ],
-      }),
-    ).toEqual([
-      {
-        id: "task-0",
-        title: "Check weather",
-        status: "complete",
-        details: "Forecast fetched",
-      },
-      { id: "task-1", title: "Summarize", status: "error" },
-    ]);
-  });
-});

package/src/runtime/{slack-task-progress.ts → task-progress.ts}

@@ -1,20 +1,6 @@
-import type { SlackStreamTask } from "@vellumai/gateway-client";
+import type { StreamPlan, StreamPlanStep } from "@vellumai/gateway-client";
 
-/**
- * A single step of a `task_progress` UI surface: an ordered, status-bearing
- * unit of work the assistant reports while a turn runs.
- */
-export type TaskProgressStep = {
-  label: string;
-  status: "pending" | "in_progress" | "completed" | "failed";
-  detail?: string;
-};
-
-export type TaskProgressData = {
-  /** Plan title shown above the steps (e.g. "Q2 Launch Plan"). */
-  title?: string;
-  steps: TaskProgressStep[];
-};
+import { coerceSurfaceDataRecord } from "../api/surfaces.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -23,7 +9,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 /** Read a `task_progress` surface payload into typed steps, if it is one. */
 export function getTaskProgressDataFromSurfaceData(
   data: unknown,
-): TaskProgressData | undefined {
+): StreamPlan | undefined {
   if (!isRecord(data)) {
     return undefined;
   }
@@ -33,12 +19,12 @@ export function getTaskProgressDataFromSurfaceData(
   return parseTaskProgressData(data.templateData);
 }
 
-function parseTaskProgressData(value: unknown): TaskProgressData | undefined {
+function parseTaskProgressData(value: unknown): StreamPlan | undefined {
   if (!isRecord(value) || !Array.isArray(value.steps)) {
     return undefined;
   }
 
-  const steps = value.steps.flatMap((step): TaskProgressStep[] => {
+  const steps = value.steps.flatMap((step): StreamPlanStep[] => {
     if (!isRecord(step)) {
       return [];
     }
@@ -72,15 +58,38 @@ function parseTaskProgressData(value: unknown): TaskProgressData | undefined {
   return { ...(title ? { title } : {}), steps };
 }
 
+/**
+ * Task progress from a `ui_show` or `ui_update` tool call's input.
+ *
+ * The model reaches for `ui_show` to draw a plan, so the card's contents ride
+ * the turn's own tool-call stream, which every channel consumer already reads.
+ * The `ui_surface_show` event the daemon publishes alongside it goes to the
+ * conversation sink instead, and no channel consumes that, so reading the tool
+ * input is what lets a channel render a plan at all.
+ *
+ * The template may sit at the top level of the input or nested under `data`,
+ * and `data` itself may arrive double-encoded as a JSON string, which is why
+ * the coercion is shared with the surface tools rather than restated here.
+ */
+export function getTaskProgressDataFromToolInput(
+  input: unknown,
+): StreamPlan | undefined {
+  const record = coerceSurfaceDataRecord(input);
+  return (
+    getTaskProgressDataFromSurfaceData(record) ??
+    getTaskProgressDataFromSurfaceData(coerceSurfaceDataRecord(record.data))
+  );
+}
+
 /**
  * Apply a `ui_surface_update` payload onto the steps already known for a
  * surface. A full `task_progress` payload replaces the steps; a partial
  * `templateData` update is merged over the existing steps.
  */
 export function mergeTaskProgressData(
-  existing: TaskProgressData | undefined,
+  existing: StreamPlan | undefined,
   data: unknown,
-): TaskProgressData | undefined {
+): StreamPlan | undefined {
   if (!isRecord(data)) {
     return existing;
   }
@@ -98,33 +107,3 @@ export function mergeTaskProgressData(
     ...(isRecord(data.templateData) ? data.templateData : {}),
   });
 }
-
-const TASK_PROGRESS_STATUS_TO_SLACK: Record<
-  TaskProgressStep["status"],
-  SlackStreamTask["status"]
-> = {
-  pending: "pending",
-  in_progress: "in_progress",
-  completed: "complete",
-  failed: "error",
-};
-
-/**
- * Map ordered `task_progress` steps onto Slack streaming task cards. Step
- * position supplies the stable card `id` (a step keeps its index across
- * updates), the label becomes the card title, the step detail becomes the
- * card details, and the surface status maps onto Slack's task-card status
- * vocabulary.
- *
- * @see https://docs.slack.dev/ai/developing-agents
- */
-export function toSlackStreamTasks(
-  progress: TaskProgressData,
-): SlackStreamTask[] {
-  return progress.steps.map((step, index) => ({
-    id: `task-${index}`,
-    title: step.label,
-    status: TASK_PROGRESS_STATUS_TO_SLACK[step.status],
-    ...(step.detail ? { details: step.detail } : {}),
-  }));
-}

package/src/security/__tests__/untrusted-content.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   escapeContentBoundaries,
+  escapeTagBoundaries,
   parseExternalContentEnvelope,
   unwrapExternalContentForDisplay,
   wrapUntrustedContent,
@@ -79,6 +80,47 @@ describe("wrapUntrustedContent", () => {
   });
 });
 
+describe("escapeTagBoundaries", () => {
+  // A complete literal tag is the easiest boundary to forge and the least
+  // interesting. Matching stops at the tag name so the near-misses a model
+  // still reads as a fence go too.
+  const VARIANTS = [
+    "</watch-timeline>",
+    "</watch-timeline >",
+    "</watch-timeline\n>",
+    "</WATCH-TIMELINE>",
+    "</WaTcH-TiMeLiNe>",
+    "</watch-timeline",
+    '</watch-timeline id="x">',
+    "<watch-timeline>",
+    "<watch-timeline",
+  ];
+
+  for (const variant of VARIANTS) {
+    test(`neutralizes ${JSON.stringify(variant)}`, () => {
+      const escaped = escapeTagBoundaries(
+        `before ${variant} after`,
+        "watch-timeline",
+      );
+      expect(escaped).not.toMatch(/<\/?watch-timeline/i);
+      expect(escaped).toContain("&lt;");
+      // Neutralized in place: the surrounding text is untouched.
+      expect(escaped.startsWith("before ")).toBe(true);
+      expect(escaped.endsWith(" after")).toBe(true);
+    });
+  }
+
+  test("leaves a different tag alone", () => {
+    const axTree = "<ax-tree>Window: Editor</ax-tree>";
+    expect(escapeTagBoundaries(axTree, "watch-timeline")).toBe(axTree);
+  });
+
+  test("leaves ordinary markup alone", () => {
+    const safe = "Hello, this is a normal note about <html> tags.";
+    expect(escapeTagBoundaries(safe, "watch-timeline")).toBe(safe);
+  });
+});
+
 describe("escapeContentBoundaries", () => {
   test("escapes closing tag", () => {
     expect(escapeContentBoundaries("</external_content>")).toBe(

package/src/security/untrusted-content.ts

@@ -58,6 +58,9 @@ const DEFAULT_BUDGETS: Record<UntrustedContentSource, number> = {
 
 const UNTRUSTED_CONTENT_SOURCE_SET = new Set<string>(UNTRUSTED_CONTENT_SOURCES);
 
+/** Name of the wrapper element untrusted content is fenced in. */
+const EXTERNAL_CONTENT_TAG_NAME = "external_content";
+
 const EXTERNAL_CONTENT_ENVELOPE_PATTERN =
   /^<external_content\s+([^\r\n<>]*)>\n([\s\S]*)\n<\/external_content>$/;
 
@@ -113,24 +116,40 @@ export function unwrapExternalContentForDisplay(value: string): string {
 }
 
 /**
- * Escape sequences that could forge or break out of the
- * `<external_content>` wrapper. Case-insensitive to cover mixed-case
+ * Escape sequences that could forge or break out of a `<tagName>` fence
+ * placed around untrusted text. Case-insensitive to cover mixed-case
  * evasion attempts.
  *
  * Both tag forms are escaped. A closing tag would end the fence early.
- * An opening tag is subtler: it lets external content fabricate what
- * reads as a second envelope — one it gets to label with any `source` it
- * likes — and it defeats any structural reasoning over the result, since
- * a forged tag is indistinguishable from a real one. Nothing legitimate
- * arrives from the outside world carrying either.
+ * An opening tag is subtler: it lets untrusted text fabricate what reads
+ * as a second fence, one it gets to label with any attribute it likes, and
+ * it defeats any structural reasoning over the result, since a forged tag
+ * is indistinguishable from a real one. Nothing legitimate arrives from
+ * the outside world carrying either.
+ *
+ * Matching stops at the tag name rather than at a closing `>`, so the
+ * variants a model still reads as a boundary are all neutralized:
+ * `</tag >`, a newline before the `>`, an unclosed `</tag`, and anything
+ * with attributes. Requiring the full literal tag would let every one of
+ * those through.
+ *
+ * Not to be confused with `escapeAxTreeContent` in
+ * `context/outbound-sanitize.ts`, which escapes the closing `</ax-tree>`
+ * only and must keep doing so: AX-tree compaction finds whole blocks by
+ * their opening tag and replaces them with a placeholder.
  */
-export function escapeContentBoundaries(content: string): string {
+export function escapeTagBoundaries(content: string, tagName: string): string {
   return content.replace(
-    /<\/?external_content/gi,
+    new RegExp(`</?${tagName}`, "gi"),
     (match) => `&lt;${match.slice(1)}`,
   );
 }
 
+/** {@link escapeTagBoundaries} for the `<external_content>` wrapper. */
+export function escapeContentBoundaries(content: string): string {
+  return escapeTagBoundaries(content, EXTERNAL_CONTENT_TAG_NAME);
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/telemetry/__tests__/live-voice-funnel.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  liveVoiceEndScreen,
+  liveVoiceSilenceReason,
+} from "../live-voice-funnel.js";
+
+describe("liveVoiceSilenceReason", () => {
+  it("blames the transport when the session never went active", () => {
+    // Nothing after `ready` can be held against a session that never got
+    // there: the user had no chance to speak.
+    expect(
+      liveVoiceSilenceReason({
+        reachedActive: false,
+        receivedAudio: false,
+        detectedSpeech: false,
+      }),
+    ).toBe("no_ready");
+  });
+
+  it("blames the transport even if stray audio arrived first", () => {
+    // Audio can land before the preflight resolves. The session still never
+    // became usable, and reporting that as a microphone problem would send
+    // someone looking in the wrong layer.
+    expect(
+      liveVoiceSilenceReason({
+        reachedActive: false,
+        receivedAudio: true,
+        detectedSpeech: true,
+      }),
+    ).toBe("no_ready");
+  });
+
+  it("reports a microphone that never opened", () => {
+    expect(
+      liveVoiceSilenceReason({
+        reachedActive: true,
+        receivedAudio: false,
+        detectedSpeech: false,
+      }),
+    ).toBe("no_audio");
+  });
+
+  it("separates a mic that opened but carried no speech", () => {
+    // The distinction that makes this taxonomy worth having: a denied
+    // permission and a muted mic both produce a silent session, and only this
+    // pair of flags tells them apart.
+    expect(
+      liveVoiceSilenceReason({
+        reachedActive: true,
+        receivedAudio: true,
+        detectedSpeech: false,
+      }),
+    ).toBe("no_speech");
+  });
+
+  it("reports speech that never became a turn", () => {
+    expect(
+      liveVoiceSilenceReason({
+        reachedActive: true,
+        receivedAudio: true,
+        detectedSpeech: true,
+      }),
+    ).toBe("no_turn");
+  });
+});
+
+describe("liveVoiceEndScreen", () => {
+  it("carries the close reason alone when nothing else applies", () => {
+    expect(liveVoiceEndScreen("client_end")).toBe("ended_client_end");
+  });
+
+  it("carries a failure code in the detail slot", () => {
+    expect(liveVoiceEndScreen("error", "invalid_field")).toBe(
+      "ended_error:invalid_field",
+    );
+  });
+
+  it("carries a silence reason when the session merely produced nothing", () => {
+    expect(liveVoiceEndScreen("client_end", null, "no_audio")).toBe(
+      "ended_client_end:silent_no_audio",
+    );
+  });
+
+  it("prefers the failure code when a session both failed and was silent", () => {
+    // A session that died on an error is explained by the error; its silence
+    // is a consequence, not a second finding.
+    expect(liveVoiceEndScreen("error", "invalid_field", "no_audio")).toBe(
+      "ended_error:invalid_field",
+    );
+  });
+
+  it("keeps every combination inside the wire field's 64-char bound", () => {
+    // `screen` is capped at 64 chars by the ingest serializer and an over-long
+    // value is dropped silently, taking the whole row with it.
+    const longest = liveVoiceEndScreen("transport_closed", null, "no_speech");
+    expect(longest.length).toBeLessThanOrEqual(64);
+  });
+
+  it("prefixes the silence value so it reads correctly in a mislabelled column", () => {
+    // It shares the detail slot with failure codes, and the admin dashboard
+    // renders that slot under a "failure code" header until it learns the
+    // difference. The prefix keeps the value honest meanwhile.
+    expect(liveVoiceEndScreen("client_end", null, "no_turn")).toContain(
+      "silent_",
+    );
+  });
+});