@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/home/__tests__/feed-writer.test.ts

@@ -459,6 +459,28 @@ describe("feed-writer", () => {
       expect(result!.summary).toBe("Fresh summary");
     });
 
+    test("a status value replaces, and a status updater reads write-time state", async () => {
+      await appendFeedItem(makeItem({ id: "item-1" }));
+
+      const replaced = await patchFeedItemContent("item-1", {
+        status: "acted_on",
+      });
+      expect(replaced!.status).toBe("acted_on");
+
+      // The updater sees the status as of the write, so a conditional
+      // transition cannot overwrite what another writer just set.
+      const observed: string[] = [];
+      const conditional = await patchFeedItemContent("item-1", {
+        status: (existing) => {
+          observed.push(existing.status);
+          return existing.status === "new" ? "seen" : existing.status;
+        },
+      });
+      expect(observed).toEqual(["acted_on"]);
+      expect(conditional!.status).toBe("acted_on");
+      expect(readFileJson().items[0]!.status).toBe("acted_on");
+    });
+
     test("returns null for an unknown id", async () => {
       await appendFeedItem(makeItem({ id: "known" }));
       expect(await patchFeedItemContent("unknown", { title: "x" })).toBeNull();

package/src/home/feed-writer.ts

@@ -185,7 +185,13 @@ export interface FeedItemContentPatch {
   title?: string;
   summary?: string;
   urgency?: FeedItemUrgency;
-  status?: FeedItemStatus;
+  /**
+   * New status, or an updater applied inside the coalescing queue so it
+   * reads the item as of write time. Use the updater for a conditional
+   * transition: a plain value would overwrite a status another writer
+   * set while the patch sat in the queue.
+   */
+  status?: FeedItemStatus | ((existing: FeedItem) => FeedItemStatus);
   /**
    * Updater for the item's guardian projection, applied inside the
    * coalescing queue so it reads the projection as of write time (a
@@ -399,7 +405,10 @@ async function runWrite(): Promise<void> {
       updated.urgency = patch.urgency;
     }
     if (patch.status !== undefined) {
-      updated.status = patch.status;
+      updated.status =
+        typeof patch.status === "function"
+          ? patch.status(existing)
+          : patch.status;
     }
     if (patch.guardianRequest !== undefined && existing.guardianRequest) {
       updated.guardianRequest = patch.guardianRequest(existing.guardianRequest);

package/src/hooks/types.ts

@@ -679,3 +679,36 @@ export interface ConversationDeletedContext
  * {@link BaseHookContext}.
  */
 export type ConversationsClearedContext = BaseHookContext;
+
+// ─── Message-deleted hook context ────────────────────────────────────────────
+
+/**
+ * Context passed to the `message-deleted` hook. Fires once per deleted
+ * message row, from the shared single-message delete primitive, after the row
+ * is removed. Whole-conversation deletes dispatch `conversation-deleted`
+ * instead.
+ *
+ * Fire-and-forget like `conversation-deleted`: the primitive is synchronous
+ * and does not wait for the chain. The row is gone by the time a hook runs,
+ * so the context carries the row's `createdAt` alongside its id. Together
+ * they are the `(createdAt, id)` position the row held, which is what a hook
+ * keeping a cursor on that row needs to record once the row can no longer be
+ * looked up. The default memory plugin contributes a hook here that stamps
+ * its retrospective cursor.
+ */
+export interface MessageDeletedInputContext {
+  /** ID of the conversation that owned the row. */
+  readonly conversationId: string;
+  /** ID of the deleted message row. */
+  readonly messageId: string;
+  /** The deleted row's `createdAt`. */
+  readonly createdAt: number;
+}
+
+/**
+ * The full `message-deleted` context a hook receives: the dispatching call
+ * site's {@link MessageDeletedInputContext} plus the pipeline-stamped
+ * {@link BaseHookContext} capabilities.
+ */
+export interface MessageDeletedContext
+  extends MessageDeletedInputContext, BaseHookContext {}

package/src/i18n/AGENTS.md

@@ -0,0 +1,22 @@
+# Daemon i18n
+
+User-facing copy the assistant generates as a hardcoded constant goes
+through `assistant/src/i18n/`. The web app has its own catalogs. This
+module is for constants the daemon writes or emits.
+
+## Rules
+
+1. Add a key to `MESSAGE_KEYS` and to every locale in `MESSAGE_CATALOGS`.
+2. Persist the key when a column holds a system constant. Never persist a
+   translated string.
+3. Resolve with `t(key, locale)` or a typed helper (`resolveConversationTitle`)
+   at the edge that emits the string.
+4. Do not match stored display strings back to keys. A stored title may be
+   in any language on purpose.
+5. Locale comes from `Accept-Language` (`localeFromAcceptLanguage`) or an
+   explicit CLI flag. Default `en` lives in this module, not at each caller.
+
+Conversation titles persist `conversation.title.generating` /
+`conversation.title.untitled`. `resolveConversationTitle` turns those keys
+into catalog copy. Legacy English placeholders stay replaceable via the
+title service patterns and pass through on the wire until they are retitled.

package/src/i18n/__tests__/i18n.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_LOCALE,
+  isMessageKey,
+  localeFromAcceptLanguage,
+  MESSAGE_CATALOGS,
+  MESSAGE_KEYS,
+  negotiateLocale,
+  resolveConversationTitle,
+  SUPPORTED_LOCALES,
+  t,
+} from "../index.js";
+
+describe("negotiateLocale", () => {
+  test("matches a full shipped tag", () => {
+    expect(negotiateLocale(["es"])).toBe("es");
+    expect(negotiateLocale(["zh-TW"])).toBe("zh-TW");
+  });
+
+  test("falls back from a regional tag to the primary language", () => {
+    expect(negotiateLocale(["es-MX", "en"])).toBe("es");
+  });
+
+  test("maps Traditional Chinese tags to zh-TW", () => {
+    expect(negotiateLocale(["zh-Hant"])).toBe("zh-TW");
+    expect(negotiateLocale(["zh-HK"])).toBe("zh-TW");
+  });
+
+  test("defaults when nothing matches", () => {
+    expect(negotiateLocale([])).toBe(DEFAULT_LOCALE);
+    expect(negotiateLocale(["xx"])).toBe(DEFAULT_LOCALE);
+  });
+});
+
+describe("localeFromAcceptLanguage", () => {
+  test("honors quality values", () => {
+    expect(localeFromAcceptLanguage("fr;q=0.8, es;q=0.9, en;q=0.5")).toBe(
+      "es",
+    );
+  });
+
+  test("defaults on missing or empty", () => {
+    expect(localeFromAcceptLanguage(null)).toBe(DEFAULT_LOCALE);
+    expect(localeFromAcceptLanguage("")).toBe(DEFAULT_LOCALE);
+  });
+});
+
+describe("catalog completeness", () => {
+  test("every locale has every key", () => {
+    const keys = Object.values(MESSAGE_KEYS);
+    for (const locale of SUPPORTED_LOCALES) {
+      for (const key of keys) {
+        expect(MESSAGE_CATALOGS[locale][key].length).toBeGreaterThan(0);
+      }
+    }
+  });
+});
+
+describe("t", () => {
+  test("resolves generating and untitled per locale", () => {
+    expect(t(MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING, "en")).toBe(
+      "Generating title...",
+    );
+    expect(t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, "en")).toBe(
+      "Untitled Conversation",
+    );
+    expect(t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, "es")).toBe(
+      "Sin título",
+    );
+  });
+});
+
+describe("resolveConversationTitle", () => {
+  test("resolves a stored key and an empty title", () => {
+    expect(
+      resolveConversationTitle(MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING, "zh"),
+    ).toBe("标题生成中...");
+    expect(resolveConversationTitle(null, "es")).toBe("Sin título");
+    expect(resolveConversationTitle("")).toBe("Untitled Conversation");
+  });
+
+  test("passes stored display strings through, including English placeholders", () => {
+    expect(resolveConversationTitle("Untitled Conversation", "es")).toBe(
+      "Untitled Conversation",
+    );
+    expect(resolveConversationTitle("Generating title...", "zh")).toBe(
+      "Generating title...",
+    );
+    expect(resolveConversationTitle("Auth Middleware Rewrite", "es")).toBe(
+      "Auth Middleware Rewrite",
+    );
+  });
+
+  test("defaults locale inside the helper", () => {
+    expect(
+      resolveConversationTitle(MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING),
+    ).toBe("Generating title...");
+  });
+});
+
+describe("isMessageKey", () => {
+  test("recognizes catalog keys only", () => {
+    expect(isMessageKey(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED)).toBe(true);
+    expect(isMessageKey("Untitled Conversation")).toBe(false);
+    expect(isMessageKey("Untitled")).toBe(false);
+  });
+});

package/src/i18n/index.ts

@@ -0,0 +1,16 @@
+export {
+  DEFAULT_LOCALE,
+  isSupportedLocale,
+  localeFromAcceptLanguage,
+  negotiateLocale,
+  SUPPORTED_LOCALES,
+  type SupportedLocale,
+} from "./locales.js";
+export {
+  isMessageKey,
+  MESSAGE_CATALOGS,
+  MESSAGE_KEYS,
+  type MessageKey,
+  t,
+} from "./messages.js";
+export { resolveConversationTitle } from "./title.js";

package/src/i18n/locales.ts

@@ -0,0 +1,93 @@
+/**
+ * Locales the daemon can resolve user-facing copy into.
+ *
+ * Keep this set aligned with `clients/web/src/i18n/supported-locales.ts`.
+ * A locale that exists only here cannot be requested by the web app; a
+ * locale that exists only there cannot be resolved for CLI or HTTP
+ * consumers that go through this module.
+ */
+
+export const DEFAULT_LOCALE = "en";
+
+export const SUPPORTED_LOCALES = ["en", "es", "ru", "zh", "zh-TW"] as const;
+
+export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
+
+export function isSupportedLocale(value: unknown): value is SupportedLocale {
+  return (
+    typeof value === "string" &&
+    (SUPPORTED_LOCALES as readonly string[]).includes(value)
+  );
+}
+
+/**
+ * Pick the best shipped locale for an ordered list of preferred BCP 47 tags.
+ *
+ * Full tag first, then the primary language subtag, so `es-MX` resolves to
+ * `es`. `zh-Hant` / `zh-HK` / `zh-MO` map to `zh-TW`.
+ */
+export function negotiateLocale(preferred: readonly string[]): SupportedLocale {
+  for (const tag of preferred) {
+    const normalized = tag.trim();
+    if (normalized === "") {
+      continue;
+    }
+    const exact = SUPPORTED_LOCALES.find(
+      (locale) => locale.toLowerCase() === normalized.toLowerCase(),
+    );
+    if (exact) {
+      return exact;
+    }
+    const lower = normalized.toLowerCase();
+    if (
+      lower === "zh-hant" ||
+      lower.startsWith("zh-hant-") ||
+      lower === "zh-hk" ||
+      lower === "zh-mo"
+    ) {
+      return "zh-TW";
+    }
+    const base = normalized.split("-")[0]?.toLowerCase();
+    const baseMatched = SUPPORTED_LOCALES.find(
+      (locale) => locale.toLowerCase() === base,
+    );
+    if (baseMatched) {
+      return baseMatched;
+    }
+  }
+  return DEFAULT_LOCALE;
+}
+
+/**
+ * Parse an `Accept-Language` header into preference order and negotiate.
+ *
+ * Quality values are honored; the header is a hint, not a required input.
+ * Missing or empty headers resolve to {@link DEFAULT_LOCALE}.
+ */
+export function localeFromAcceptLanguage(
+  header: string | null | undefined,
+): SupportedLocale {
+  if (header == null || header.trim() === "") {
+    return DEFAULT_LOCALE;
+  }
+  const tags = header
+    .split(",")
+    .map((part) => {
+      const [tag, ...params] = part.trim().split(";");
+      let quality = 1;
+      for (const param of params) {
+        const [name, value] = param.trim().split("=");
+        if (name === "q" && value !== undefined) {
+          const parsed = Number.parseFloat(value);
+          if (Number.isFinite(parsed)) {
+            quality = parsed;
+          }
+        }
+      }
+      return { tag: tag?.trim() ?? "", quality };
+    })
+    .filter((entry) => entry.tag.length > 0)
+    .sort((a, b) => b.quality - a.quality)
+    .map((entry) => entry.tag);
+  return negotiateLocale(tags);
+}

package/src/i18n/messages.ts

@@ -0,0 +1,61 @@
+/**
+ * Daemon message catalog.
+ *
+ * Keys are the stable identity of a hardcoded constant. English is the
+ * source language. Add a key here, then add the same key to every locale
+ * catalog. A key present in a translated catalog but missing from English
+ * is a test failure.
+ *
+ * Persist the key when a column holds a system constant. Never persist a
+ * translated string, and never treat a stored display string as a key:
+ * a user title may be in any language.
+ */
+
+import {
+  DEFAULT_LOCALE,
+  type SupportedLocale,
+} from "./locales.js";
+
+export const MESSAGE_KEYS = {
+  CONVERSATION_TITLE_GENERATING: "conversation.title.generating",
+  CONVERSATION_TITLE_UNTITLED: "conversation.title.untitled",
+} as const;
+
+export type MessageKey = (typeof MESSAGE_KEYS)[keyof typeof MESSAGE_KEYS];
+
+export const MESSAGE_CATALOGS: Record<
+  SupportedLocale,
+  Record<MessageKey, string>
+> = {
+  en: {
+    "conversation.title.generating": "Generating title...",
+    "conversation.title.untitled": "Untitled Conversation",
+  },
+  es: {
+    "conversation.title.generating": "Generando título...",
+    "conversation.title.untitled": "Sin título",
+  },
+  ru: {
+    "conversation.title.generating": "Создание названия...",
+    "conversation.title.untitled": "Без названия",
+  },
+  zh: {
+    "conversation.title.generating": "标题生成中...",
+    "conversation.title.untitled": "无标题",
+  },
+  "zh-TW": {
+    "conversation.title.generating": "標題產生中...",
+    "conversation.title.untitled": "未命名",
+  },
+};
+
+export function t(
+  key: MessageKey,
+  locale: SupportedLocale = DEFAULT_LOCALE,
+): string {
+  return MESSAGE_CATALOGS[locale][key] ?? MESSAGE_CATALOGS[DEFAULT_LOCALE][key];
+}
+
+export function isMessageKey(value: string): value is MessageKey {
+  return (Object.values(MESSAGE_KEYS) as string[]).includes(value);
+}

package/src/i18n/title.ts

@@ -0,0 +1,25 @@
+/**
+ * Resolve a conversation title for a locale.
+ *
+ * A stored message key (or an empty title) is a hardcoded constant and
+ * resolves through the catalog. Any other stored string is user or model
+ * copy and passes through, including English placeholders written before
+ * keys were persisted.
+ */
+
+import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
+import { isMessageKey, MESSAGE_KEYS, t } from "./messages.js";
+
+export function resolveConversationTitle(
+  title: string | null | undefined,
+  locale: SupportedLocale = DEFAULT_LOCALE,
+): string {
+  const trimmed = title?.trim() ?? "";
+  if (trimmed === "") {
+    return t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, locale);
+  }
+  if (isMessageKey(trimmed)) {
+    return t(trimmed, locale);
+  }
+  return trimmed;
+}

package/src/inbound/platform-callback-registration.ts

@@ -18,9 +18,10 @@
  * the platform can register a route that points at this instance.
  */
 
-import { getPlatformAssistantId, getPlatformBaseUrl } from "../config/env.js";
+import { getPlatformBaseUrl } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
+import { resolvePlatformAssistantId } from "../config/platform-identity.js";
 import { ipcRegisterWebhookRoute } from "../ipc/gateway-client.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -45,11 +46,11 @@ export interface PlatformCallbackRegistrationContext {
 
 export async function resolvePlatformCallbackRegistrationContext(): Promise<PlatformCallbackRegistrationContext> {
   const platform = getIsPlatform();
-  const [storedBaseUrlRaw, storedAssistantIdRaw, storedAssistantApiKeyRaw] =
+  const [storedBaseUrlRaw, storedAssistantApiKeyRaw, assistantId] =
     await Promise.all([
       getSecureKeyAsync(credentialKey("vellum", "platform_base_url")),
-      getSecureKeyAsync(credentialKey("vellum", "platform_assistant_id")),
       getSecureKeyAsync(credentialKey("vellum", "assistant_api_key")),
+      resolvePlatformAssistantId(),
     ]);
 
   const storedBaseUrl = storedBaseUrlRaw?.trim();
@@ -57,8 +58,6 @@ export async function resolvePlatformCallbackRegistrationContext(): Promise<Plat
     /\/+$/,
     "",
   );
-  const assistantId =
-    getPlatformAssistantId().trim() || storedAssistantIdRaw?.trim() || "";
   const envAssistantCredential = process.env.ASSISTANT_API_KEY?.trim();
   const assistantCredential =
     storedAssistantApiKeyRaw?.trim() || envAssistantCredential || undefined;

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

@@ -980,3 +980,124 @@ describe("LiveVoiceSession room reveal", () => {
     expect(ttsTexts.join(" ")).not.toContain("ASK_GUARDIAN_APPROVAL");
   });
 });
+
+describe("LiveVoiceSession spoken session controls", () => {
+  function createControlsHarness(
+    sessionControls?: LiveVoiceClientStartFrame["sessionControls"],
+  ) {
+    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const harness = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+      startFrame: {
+        ...START_FRAME,
+        ...(sessionControls ? { sessionControls } : {}),
+      },
+    });
+    return { ...harness, getCallbacks, ttsTexts };
+  }
+
+  test("a reply ending with [END_CALL] sends an end control after tts_done", async () => {
+    const { frames, session, getCallbacks, ttsTexts } = createControlsHarness([
+      "end",
+      "mute",
+    ]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Okay, talk soon. [END_CALL]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "session_control"),
+    );
+
+    const ttsDoneIndex = frames.findIndex((frame) => frame.type === "tts_done");
+    const controlIndex = frames.findIndex(
+      (frame) => frame.type === "session_control",
+    );
+    // The goodbye is heard before the call ends.
+    expect(controlIndex).toBeGreaterThan(ttsDoneIndex);
+    expect(frames[controlIndex]).toMatchObject({
+      type: "session_control",
+      turnId: "live-turn-1",
+      action: "end",
+    });
+    expect(assistantDeltaTexts(frames).join("").trim()).toBe(
+      "Okay, talk soon.",
+    );
+    expect(ttsTexts.join(" ")).not.toContain("[END_CALL]");
+  });
+
+  test("a timed mute carries its duration", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["mute"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Muting you for thirty seconds. [MUTE:30]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "session_control"),
+    );
+
+    expect(
+      frames.find((frame) => frame.type === "session_control"),
+    ).toMatchObject({ action: "mute", durationMs: 30_000 });
+  });
+
+  test("a control the client did not declare is never sent", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["mute"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Bye. [END_CALL]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+    await flushAsyncCallbacks();
+
+    expect(frames.some((frame) => frame.type === "session_control")).toBe(
+      false,
+    );
+  });
+
+  test("a marker mid-reply controls nothing", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["end"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Say [END_CALL] and I would hang up, but no.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+    await flushAsyncCallbacks();
+
+    expect(frames.some((frame) => frame.type === "session_control")).toBe(
+      false,
+    );
+  });
+
+  // Talking over "okay, bye" means they are not leaving.
+  test("an interrupted goodbye does not end the call", async () => {
+    const { frames, session, getCallbacks } = createControlsHarness(["end"]);
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Okay, talk soon. [END_CALL]");
+    await flushAsyncCallbacks();
+    await session.handleClientFrame({ type: "interrupt" });
+    emitMessageComplete(getCallbacks);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(frames.some((frame) => frame.type === "session_control")).toBe(
+      false,
+    );
+  });
+
+  test("the prompt teaches only the declared controls", async () => {
+    const { session, getCallbacks, startVoiceTurn } = createControlsHarness([
+      "mute",
+    ]);
+
+    await startReleasedTurn(session, getCallbacks);
+    const prompt =
+      (startVoiceTurn as ReturnType<typeof mock>).mock.calls[0]?.[0]
+        ?.voiceControlPrompt ?? "";
+
+    expect(prompt).toContain("[MUTE]");
+    expect(prompt).not.toContain("[END_CALL]");
+  });
+});

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

@@ -253,14 +253,15 @@ describe("LiveVoiceSession archive and metrics events", () => {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
       // Pins the full production control prompt for the FRONT-DOOR leg (the
-      // first leg of every routed turn): the speech-first rule, and nothing
-      // else. This leg is toolless, so both the screen-reveal and setup-flow
-      // teachings are deliberately absent. It has nothing to show and no
-      // connection to run, and its capability digest already routes anything
-      // needing a tool to the escalated leg (see
-      // live-voice-triage-escalate.test.ts).
+      // first leg of every routed turn): the speech-first rule and the session
+      // controls, and nothing else. This leg is toolless, so both the
+      // screen-reveal and setup-flow teachings are deliberately absent. It
+      // has nothing to show and no connection to run, and its capability
+      // digest already routes anything needing a tool to the escalated leg
+      // (see live-voice-triage-escalate.test.ts). The start frame declares no
+      // client controls, so only the session's own update cadence is taught.
       voiceControlPrompt:
-        "You are speaking in a local live voice session. Keep each reply to one to three spoken sentences. The caller is listening, not reading: lead with the answer, say it in the fewest words that are still complete, and stop. No preamble, no recap of the question, no closing offer of more. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links), bulleted or numbered lists, or emojis. Write plain conversational text only; if something is naturally a list, say it as one sentence. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. ",
+        'You are speaking in a local live voice session. Keep each reply to one to three spoken sentences. The caller is listening, not reading: lead with the answer, say it in the fewest words that are still complete, and stop. No preamble, no recap of the question, no closing offer of more. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links), bulleted or numbered lists, or emojis. Write plain conversational text only; if something is naturally a list, say it as one sentence. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work, or a card with an image or a link instead of reading an address out); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. The user can also control this call by asking you. Only when they clearly ask:\n- To hear fewer spoken progress updates while you work (for example "don\'t give me updates so often"), confirm that you will only check in now and then and will tell them when it is done, then end your reply with [UPDATES:FEWER]. If they later want regular updates back, confirm and end with [UPDATES:NORMAL].\nThe marker must be the very last thing in your reply. It is never spoken and does nothing anywhere else.',
     });
     callbacks?.assistant_text_delta?.(makeTextDelta("Hello there."));
     callbacks?.message_complete?.(makeMessageComplete());

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

@@ -329,7 +329,6 @@ describe("LiveVoiceMetricsCollector", () => {
       endpointHoldCount: 0,
       endpointDecisionMaxLatencyMs: 95,
     });
-    expect(completed).not.toHaveProperty("ackSpoken");
   });
 
   test("decisions without a source are attributed to the front door", () => {
@@ -435,7 +434,6 @@ describe("LiveVoiceMetricsCollector", () => {
     expect(completed).not.toHaveProperty("endpointHoldCount");
     expect(completed).not.toHaveProperty("endpointDecisionMaxLatencyMs");
     expect(completed).not.toHaveProperty("endpointDecisionSource");
-    expect(completed).not.toHaveProperty("ackSpoken");
     expect(completed).not.toHaveProperty("progressUpdatesSpoken");
 
     const aggregateFields = getLiveVoiceMetricsAggregateFields(
@@ -446,7 +444,6 @@ describe("LiveVoiceMetricsCollector", () => {
     expect(aggregateFields).not.toHaveProperty("endpointHoldCount");
     expect(aggregateFields).not.toHaveProperty("endpointDecisionMaxLatencyMs");
     expect(aggregateFields).not.toHaveProperty("endpointDecisionSource");
-    expect(aggregateFields).not.toHaveProperty("ackSpoken");
     expect(aggregateFields).not.toHaveProperty("progressUpdatesSpoken");
   });