@vellumai/assistant 0.11.10-dev.202609092113.0fb45bc → 0.11.10-dev.202609092314.f7dc525

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/reactions.ts

@@ -41,6 +41,12 @@ export const ReactionEmojiFieldsSchema = z.object({
 });
 export type ReactionEmojiFields = z.infer<typeof ReactionEmojiFieldsSchema>;
 
+/** The typed fields with the kind and name known. */
+export type ReactionEmojiIdentity = ReactionEmojiFields & {
+  emojiKind: ReactionEmojiKind;
+  emojiName: string;
+};
+
 /**
  * The typed emoji fields a source actually carries, with undefined ones
  * omitted: an absent key and a present-but-undefined one serialize alike, but the
@@ -96,7 +102,7 @@ export function parseDiscordEmojiMention(
  */
 export function classifyReactionEmojiSpelling(
   emoji: string,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   const custom = parseDiscordEmojiMention(emoji);
   if (custom) {
     // The plain `<:name:id>` form says nothing about animation: the
@@ -123,7 +129,7 @@ export function classifyReactionEmojiSpelling(
  */
 export function reactionEmojiIdentity(
   reaction: { emoji: string } & ReactionEmojiFields,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   return reaction.emojiKind !== undefined && reaction.emojiName !== undefined
     ? {
         ...pickReactionEmojiFields(reaction),

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/reactions.ts

@@ -41,6 +41,12 @@ export const ReactionEmojiFieldsSchema = z.object({
 });
 export type ReactionEmojiFields = z.infer<typeof ReactionEmojiFieldsSchema>;
 
+/** The typed fields with the kind and name known. */
+export type ReactionEmojiIdentity = ReactionEmojiFields & {
+  emojiKind: ReactionEmojiKind;
+  emojiName: string;
+};
+
 /**
  * The typed emoji fields a source actually carries, with undefined ones
  * omitted: an absent key and a present-but-undefined one serialize alike, but the
@@ -96,7 +102,7 @@ export function parseDiscordEmojiMention(
  */
 export function classifyReactionEmojiSpelling(
   emoji: string,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   const custom = parseDiscordEmojiMention(emoji);
   if (custom) {
     // The plain `<:name:id>` form says nothing about animation: the
@@ -123,7 +129,7 @@ export function classifyReactionEmojiSpelling(
  */
 export function reactionEmojiIdentity(
   reaction: { emoji: string } & ReactionEmojiFields,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   return reaction.emojiKind !== undefined && reaction.emojiName !== undefined
     ? {
         ...pickReactionEmojiFields(reaction),

package/node_modules/@vellumai/gateway-client/src/inbound-contract.ts

@@ -85,6 +85,12 @@ export const SourceMetadataSchema = z
     commandIntent: CommandIntentSchema.optional(),
     /** Slack-specific: whether the bot was @-mentioned. */
     slackBotMentioned: z.boolean().optional(),
+    /**
+     * Slack-specific: the `edited.ts` float-string from a `message_changed`
+     * event. Used by the daemon to reject out-of-order edit deliveries whose
+     * edit timestamp is older than the one already stored.
+     */
+    slackEditedTs: z.string().optional(),
     /** Slack workspace/team ID. */
     account: z.string().optional(),
     /**

package/node_modules/@vellumai/gateway-client/src/outbound-contract.ts

@@ -287,6 +287,14 @@ export const ChannelDeliveryResultSchema = z.object({
   ok: z.boolean(),
   /** The message timestamp returned by the delivery endpoint. */
   ts: z.string().optional(),
+  /**
+   * Every provider post the text of this delivery created, in send order, in
+   * the channel's own id space: one id for a single post, one per chunk when
+   * the channel split the text. Posts made for attachments are not included.
+   * A recorder needs every one of these, since a reaction, edit, or delete
+   * can name any chunk; `ts` alone names at most one.
+   */
+  messageIds: z.array(z.string()).optional(),
 });
 
 export type ChannelDeliveryResult = z.infer<typeof ChannelDeliveryResultSchema>;

package/node_modules/@vellumai/service-contracts/src/reactions.ts

@@ -41,6 +41,12 @@ export const ReactionEmojiFieldsSchema = z.object({
 });
 export type ReactionEmojiFields = z.infer<typeof ReactionEmojiFieldsSchema>;
 
+/** The typed fields with the kind and name known. */
+export type ReactionEmojiIdentity = ReactionEmojiFields & {
+  emojiKind: ReactionEmojiKind;
+  emojiName: string;
+};
+
 /**
  * The typed emoji fields a source actually carries, with undefined ones
  * omitted: an absent key and a present-but-undefined one serialize alike, but the
@@ -96,7 +102,7 @@ export function parseDiscordEmojiMention(
  */
 export function classifyReactionEmojiSpelling(
   emoji: string,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   const custom = parseDiscordEmojiMention(emoji);
   if (custom) {
     // The plain `<:name:id>` form says nothing about animation: the
@@ -123,7 +129,7 @@ export function classifyReactionEmojiSpelling(
  */
 export function reactionEmojiIdentity(
   reaction: { emoji: string } & ReactionEmojiFields,
-): ReactionEmojiFields & { emojiKind: ReactionEmojiKind; emojiName: string } {
+): ReactionEmojiIdentity {
   return reaction.emojiKind !== undefined && reaction.emojiName !== undefined
     ? {
         ...pickReactionEmojiFields(reaction),

package/node_modules/@vellumai/slack-text/src/emoji.test.ts

@@ -20,6 +20,12 @@ describe("slackEmojiCharacter", () => {
     expect(glyph(slackEmojiCharacter("thumbsup::skin-tone-3"))).toBe("👍🏼");
   });
 
+  test("a same-tone composite repeats the tone for each person", () => {
+    expect(
+      glyph(slackEmojiCharacter("people_holding_hands::skin-tone-3")),
+    ).toBe(glyph("🧑🏼‍🤝‍🧑🏼"));
+  });
+
   test("places the tone inside a multi-person sequence", () => {
     expect(glyph(slackEmojiCharacter("woman-raising-hand::skin-tone-2"))).toBe(
       glyph("🙋🏻‍♀️"),

package/node_modules/@vellumai/slack-text/src/emoji.ts

@@ -54,11 +54,13 @@ export function slackEmojiCharacter(name: string): string | undefined {
     return entry.unicode;
   }
   const modifier = SKIN_TONE_MODIFIERS[Number(toned[2]) - 2]!;
+  // A multi-person emoji repeats the tone for each person; the variant
+  // Slack's single suffix names is the one carrying that tone and no other.
   const skin = entry.skins?.find((s) => {
     const modifiers = s.hexcode
       .split("-")
       .filter((h) => SKIN_TONE_MODIFIERS.includes(h));
-    return modifiers.length === 1 && modifiers[0] === modifier;
+    return modifiers.length > 0 && modifiers.every((h) => h === modifier);
   });
   return skin?.unicode ?? entry.unicode;
 }

package/openapi.yaml

@@ -4553,6 +4553,8 @@ paths:
                         - type
                     slackBotMentioned:
                       type: boolean
+                    slackEditedTs:
+                      type: string
                     account:
                       type: string
                     actorTeamId:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.10-dev.202609092113.0fb45bc",
+  "version": "0.11.10-dev.202609092314.f7dc525",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/channel-guardian.test.ts

@@ -38,6 +38,7 @@ const telegramDeliverCalls: Array<{
 mock.module("../messaging/providers/telegram-bot/send.js", () => ({
   sendTelegramReply: async (chatId: string, text: string) => {
     telegramDeliverCalls.push({ chatId, text });
+    return { messageIds: [] };
   },
   sendTelegramAttachments: async () => ({
     allFailed: false,

package/src/__tests__/discord-callback-round-trip.test.ts

@@ -19,13 +19,18 @@ const sent: Array<{ channelId: string; text: string }> = [];
 // need. `mock.module` replaces the module wholesale, so a partial stub breaks
 // the transport's import of any export it omits, and would break again the
 // next time `send.ts` grows one.
+const { acknowledgedSend } =
+  await import("../messaging/providers/send-result.js");
 const actualSend = await import("../messaging/providers/discord/send.js");
 
+const actualDiscordSend =
+  await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
+  ...actualDiscordSend,
   ...actualSend,
   sendDiscordReply: async (target: { channelId: string }, text: string) => {
     sent.push({ channelId: target.channelId, text });
-    return { messageId: "1401234567890123456" };
+    return acknowledgedSend(["1401234567890123456"]);
   },
 }));
 

package/src/__tests__/messaging-send-tool.test.ts

@@ -42,6 +42,17 @@ function makeProvider(id: string, displayName: string): MessagingProvider {
 const phoneProvider = makeProvider("phone", "Phone");
 const telegramProvider = makeProvider("telegram", "Telegram");
 const outlookProvider = makeProvider("outlook", "Outlook");
+// Slack's provider threads exactly where it is told and reports that thread
+// on the result; Telegram's ignores a requested thread and reports none.
+const slackProvider: MessagingProvider = {
+  ...makeProvider("slack", "Slack"),
+  sendMessage: async (_connection, conversationId, _text, options) => ({
+    id: "1700000000.000100",
+    timestamp: 123,
+    conversationId,
+    ...(options?.threadId ? { threadId: options.threadId } : {}),
+  }),
+};
 let provider: MessagingProvider = phoneProvider;
 
 let connection: OAuthConnection | undefined = undefined;
@@ -125,6 +136,13 @@ mock.module("../notifications/conversation-pairing.js", () => ({
   resolveProactiveHomeConversation: resolveProactiveHomeConversationMock,
 }));
 
+mock.module("../persistence/external-conversation-store.js", () => ({
+  normalizeExternalThreadId: (value: string | null | undefined) => {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+  },
+}));
+
 mock.module("../notifications/delivered-post-record.js", () => ({
   recordDeliveredChannelPost: recordDeliveredChannelPostMock,
 }));
@@ -349,6 +367,136 @@ describe("messaging-send tool", () => {
     expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
   });
 
+  test("records nothing when the post landed in the turn's own thread, even though the home is elsewhere", async () => {
+    // A Slack agent-style DM keys one conversation per thread. Its home
+    // resolves to the chat's notification conversation, so the home test
+    // alone would record this send as a cross-post away from the thread it
+    // was made in. The turn's own snapshot (channel, chat, thread) decides
+    // instead, against the thread the provider says it delivered into.
+    provider = slackProvider;
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        thread_id: "1700000000.000001",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "slack",
+        requesterChatId: "D0123456789",
+        sourceThreadId: "1700000000.000001",
+      },
+    );
+
+    expect(resolveProactiveHomeConversationMock).not.toHaveBeenCalled();
+    expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
+  });
+
+  test("records a send into the turn's chat but a different thread as a cross-post", async () => {
+    provider = slackProvider;
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        thread_id: "1700000000.000002",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "slack",
+        requesterChatId: "D0123456789",
+        sourceThreadId: "1700000000.000001",
+      },
+    );
+
+    expect(resolveProactiveHomeConversationMock).toHaveBeenCalledTimes(1);
+    expect(recordDeliveredChannelPostMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("a thread-less delivery never matches a turn that arrived in a thread", async () => {
+    provider = slackProvider;
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "slack",
+        requesterChatId: "D0123456789",
+        sourceThreadId: "1700000000.000001",
+      },
+    );
+
+    expect(recordDeliveredChannelPostMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("decides by where the provider delivered, not by the thread requested", async () => {
+    // Telegram's provider ignores a requested thread and reports none, so a
+    // turn that arrived in a topic and asked for that topic still gets a
+    // post in the thread-less chat; that post is recorded, not suppressed.
+    provider = telegramProvider;
+
+    await run(
+      {
+        platform: "telegram",
+        conversation_id: "123456789",
+        thread_id: "777",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+        executionChannel: "telegram",
+        requesterChatId: "123456789",
+        sourceThreadId: "777",
+      },
+    );
+
+    expect(recordDeliveredChannelPostMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("a turn that arrived through no channel falls back to the home comparison", async () => {
+    provider = slackProvider;
+    resolveProactiveHomeConversationMock.mockImplementation(async () => ({
+      conversationId: "conv-A",
+      createdNewConversation: false,
+    }));
+
+    await run(
+      {
+        platform: "slack",
+        conversation_id: "D0123456789",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-A",
+        assistantId: "ast-1",
+        trustClass: "guardian" as const,
+      },
+    );
+
+    expect(resolveProactiveHomeConversationMock).toHaveBeenCalledTimes(1);
+    expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
+  });
+
   test("records nothing for a provider that is not a channel", async () => {
     provider = outlookProvider;
     connection = {

package/src/__tests__/notification-discord-adapter.test.ts

@@ -29,9 +29,14 @@ mock.module("../messaging/providers/discord/api.js", () => ({
   },
 }));
 
+const { acknowledgedSend } =
+  await import("../messaging/providers/send-result.js");
 const actualSend = await import("../messaging/providers/discord/send.js");
+const actualDiscordSend =
+  await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
-  DiscordPartialSendError: actualSend.DiscordPartialSendError,
+  ...actualDiscordSend,
+  ...actualSend,
   sendDiscordReply: async (
     target: { channelId: string },
     text: string,
@@ -48,7 +53,7 @@ mock.module("../messaging/providers/discord/send.js", () => ({
         : new Error("simulated component rejection");
     }
     sendCalls.push({ channelId: target.channelId, text, approval });
-    return { lastMessageId: String(2000 + sendCalls.length) };
+    return acknowledgedSend([String(2000 + sendCalls.length)]);
   },
   editDiscordMessage: async (
     target: { channelId: string },

package/src/__tests__/notification-slack-adapter.test.ts

@@ -18,7 +18,9 @@ const sendCalls: Array<{
 }> = [];
 
 const actualSend = await import("../messaging/providers/slack/send.js");
+const actualSlackSend = await import("../messaging/providers/slack/send.js");
 mock.module("../messaging/providers/slack/send.js", () => ({
+  ...actualSlackSend,
   ...actualSend,
   sendSlackReply: async (
     chatId: string,

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -22,7 +22,12 @@ const editCalls: Array<{
 /** When set, editTelegramMessage rejects with this message. */
 let editFailure: string | undefined;
 
+const { acknowledgedSend } =
+  await import("../messaging/providers/send-result.js");
+const actualTelegramSend =
+  await import("../messaging/providers/telegram-bot/send.js");
 mock.module("../messaging/providers/telegram-bot/send.js", () => ({
+  ...actualTelegramSend,
   sendTelegramReply: async (
     chatId: string,
     text: string,
@@ -36,9 +41,9 @@ mock.module("../messaging/providers/telegram-bot/send.js", () => ({
       text,
       approval: approval as (typeof sendCalls)[0]["approval"],
     });
-    // Mirror the real send result: the id of the sent message, which the
-    // adapter surfaces so the delivery row can address the card later.
-    return { lastMessageId: String(1000 + sendCalls.length) };
+    // The real send result: the id of the sent message, which the adapter
+    // surfaces so the delivery row can address the card later.
+    return acknowledgedSend([String(1000 + sendCalls.length)]);
   },
   sendTelegramAttachments: async () => ({
     allFailed: false,

package/src/__tests__/slack-edit-ordering-characterization.test.ts

@@ -53,7 +53,11 @@ async function seedMessage(): Promise<string> {
   return inserted.id;
 }
 
-async function applyEdit(eventId: string, content: string): Promise<void> {
+async function applyEdit(
+  eventId: string,
+  content: string,
+  slackEditedTs?: string,
+): Promise<void> {
   await handleEditIntercept({
     sourceChannel: "slack",
     conversationExternalId: CHANNEL,
@@ -61,6 +65,7 @@ async function applyEdit(eventId: string, content: string): Promise<void> {
     sourceMessageId: ORIGINAL_TS,
     assistantId: "self",
     content,
+    slackEditedTs,
   });
 }
 
@@ -90,10 +95,17 @@ describe("Slack edit ordering (characterization)", () => {
     expect(stringifyMessageContent(row!.content)).toBe("revised text");
   });
 
-  test.todo(
-    "GUARD (future PR): an edit whose Slack edited.ts is older than the stored one is ignored",
-    () => {},
-  );
+  test("GUARD: an edit whose Slack edited.ts is older than the stored one is ignored", async () => {
+    const messageId = await seedMessage();
+
+    // The newer edit (ts = .000300) arrives first and is applied.
+    await applyEdit("edit-event-newer", "second revision", "1700000000.000300");
+    // The older edit (ts = .000200) arrives late; the guard must reject it.
+    await applyEdit("edit-event-older", "first revision", "1700000000.000200");
+
+    const row = getMessageById(messageId);
+    expect(stringifyMessageContent(row!.content)).toBe("second revision");
+  });
 
   test.todo(
     "GUARD (future PR): content and mention source data are replaced in the same transaction on every applied edit",

package/src/__tests__/verification-outbound-delivery.test.ts

@@ -33,7 +33,9 @@ mock.module("../config/env.js", () => ({
 const deliveries: Array<{ transport: string; to: string; text: string }> = [];
 
 const realSlackSend = await import("../messaging/providers/slack/send.js");
+const actualSlackSend = await import("../messaging/providers/slack/send.js");
 mock.module("../messaging/providers/slack/send.js", () => ({
+  ...actualSlackSend,
   ...realSlackSend,
   sendSlackReply: async (chatId: string, text: string) => {
     deliveries.push({ transport: "slack", to: chatId, text });
@@ -47,7 +49,7 @@ mock.module("../messaging/providers/telegram-bot/send.js", () => ({
   ...realTelegramSend,
   sendTelegramReply: async (chatId: string, text: string) => {
     deliveries.push({ transport: "telegram", to: chatId, text });
-    return {};
+    return { messageIds: [] };
   },
 }));
 
@@ -59,11 +61,14 @@ mock.module("../messaging/providers/discord/api.js", () => ({
 }));
 
 const realDiscordSend = await import("../messaging/providers/discord/send.js");
+const actualDiscordSend =
+  await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
+  ...actualDiscordSend,
   ...realDiscordSend,
   sendDiscordReply: async (target: { channelId: string }, text: string) => {
     deliveries.push({ transport: "discord", to: target.channelId, text });
-    return {};
+    return { messageIds: [] };
   },
 }));
 

package/src/calls/spoken-reply-rules.ts

@@ -0,0 +1,20 @@
+/**
+ * Model-facing rules for any reply that is synthesized to speech. Shared by
+ * the phone-call control prompt (voice-session-bridge.ts) and the in-app
+ * live-voice control prompt (live-voice/live-voice-session.ts) so the two
+ * surfaces cannot drift on what a spoken reply is allowed to look like.
+ *
+ * Both rules describe the delivery path, not the surface: the caller hears
+ * the text, and sanitizeForTts (tts-text-sanitizer.ts) strips markdown
+ * syntax but keeps the content, so a five-bullet answer is still five
+ * bullets of audio with the dashes removed. The length rule is what keeps
+ * that answer from being produced in the first place.
+ */
+
+/** One to three spoken sentences; the caller is listening, not reading. */
+export const SPOKEN_REPLY_LENGTH_RULE =
+  "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.";
+
+/** Plain conversational text only; the text goes straight to a TTS engine. */
+export const SPOKEN_REPLY_PLAIN_TEXT_RULE =
+  "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.";

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

@@ -58,6 +58,10 @@ import { sensitiveToolReach } from "../tools/tool-approval-handler.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import { truncate } from "../util/truncate.js";
+import {
+  SPOKEN_REPLY_LENGTH_RULE,
+  SPOKEN_REPLY_PLAIN_TEXT_RULE,
+} from "./spoken-reply-rules.js";
 import {
   CALL_OPENING_MARKER,
   CALL_VERIFICATION_COMPLETE_MARKER,
@@ -630,7 +634,7 @@ function buildVoiceCallControlPrompt(opts: {
   lines.push(
     "CALL PROTOCOL RULES:",
     disclosureRule,
-    "1. Be concise — keep responses to 1-3 sentences. Phone conversations should be brief and natural.",
+    `1. ${SPOKEN_REPLY_LENGTH_RULE}`,
     ...(opts.isCallerGuardian
       ? [
           "2. You are speaking directly with your guardian (your user). Do NOT use [ASK_GUARDIAN:]. If you need permission, information, or confirmation, ask them directly in the conversation. They can answer you right now.",
@@ -691,7 +695,7 @@ function buildVoiceCallControlPrompt(opts: {
   lines.push(
     "9. After the opening greeting turn, treat the Task field as background context only — do not re-execute its instructions on subsequent turns.",
     '10. Do not make up information. If you are unsure, use [ASK_GUARDIAN: your question] to consult your guardian. For tool permission requests, use [ASK_GUARDIAN_APPROVAL: {"question":"...","toolName":"...","input":{...}}].',
-    `11. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links) or emojis in your spoken responses. Write plain conversational text only. Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
+    `11. ${SPOKEN_REPLY_PLAIN_TEXT_RULE} Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
     `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, ${preSpeechLanguageRuleFragment(config.services.stt.language, sttCatalogKeyForRole(config.services.stt, "telephony"))}.`,
     `13. ${PHONE_NO_SETUP_FLOWS_RULE}`,
   );

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

@@ -334,7 +334,7 @@ export function createFrontDoorStreamGate(
  * just above it.
  */
 export const ESCALATION_CONTINUATION_CONTENT =
-  "(You just told the caller you needed a moment to think. Now give them your full, careful answer to their previous question — do not repeat the holding phrase.)";
+  "(You just told the caller you needed a moment to think. Now answer their previous question out loud. Cover what they asked, but as a few spoken sentences rather than a written write-up: they are listening, not reading. Do not repeat the holding phrase.)";
 
 /**
  * Compact, registry-derived digest of the tools the ESCALATED leg can use.

package/src/channels/__tests__/types.test.ts

@@ -4,6 +4,7 @@ import {
   CLIENT_OS_VALUES,
   INTERACTIVE_INTERFACES,
   INTERFACE_IDS,
+  type InterfaceId,
   isInterfaceId,
   parseClientOs,
   parseInterfaceId,
@@ -90,6 +91,22 @@ describe("parseInterfaceId", () => {
 });
 
 describe("supportsHostProxy", () => {
+  // The capability table is a plain object, so an id that names something on
+  // Object.prototype must not resolve to the inherited member. Lookups use
+  // Object.hasOwn; with `in` these return a function and the caller throws.
+  test("object prototype keys are not interfaces", () => {
+    for (const id of [
+      "toString",
+      "constructor",
+      "valueOf",
+      "hasOwnProperty",
+      "isPrototypeOf",
+    ] as unknown as InterfaceId[]) {
+      expect(supportsHostProxy(id)).toBe(false);
+      expect(supportsHostProxy(id, "host_bash")).toBe(false);
+    }
+  });
+
   // ── macOS: supports all four host proxy capabilities. ──
   test("macos returns true (no capability)", () => {
     expect(supportsHostProxy("macos")).toBe(true);