@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/calls/media-stream-server.ts

@@ -38,6 +38,7 @@
  * - Media stream `stop` event / WebSocket close -> finalize call.
  */
 
+import { GATEWAY_TUNNEL_LOST_WS_CLOSE_CODE } from "@vellumai/service-contracts/ingress";
 import type { ServerWebSocket } from "bun";
 
 import { revokeScopedApprovalGrantsForContext } from "../approvals/scoped-approval-grants.js";
@@ -80,6 +81,7 @@ import {
   type MediaStreamSttSessionCallbacks,
   type MediaStreamSttSessionConfig,
 } from "./media-stream-stt-session.js";
+import { resolveTelephonySynthesisLanguage } from "./telephony-synthesis-language.js";
 import {
   TRUST_UNAVAILABLE_DENY_MESSAGE,
   unresolvedActorTrust,
@@ -191,6 +193,14 @@ export class MediaStreamCallSession {
   /** Number of transcript finals produced (non-empty). */
   private transcriptFinalsProduced = 0;
 
+  /**
+   * Synthesized speech follows the caller's latest detected language when
+   * the transcriber tags finals, falling back to the pin-based
+   * resolution. Shared by the output adapter and the call controller.
+   */
+  private readonly resolveSynthesisLanguage = (): string | undefined =>
+    resolveTelephonySynthesisLanguage(this.sttSession.currentLanguage());
+
   constructor(
     ws: ServerWebSocket<unknown>,
     callSessionId: string,
@@ -215,6 +225,8 @@ export class MediaStreamCallSession {
 
     this.sttSession = new MediaStreamSttSession(sttConfig ?? {}, callbacks);
 
+    this.output.setSynthesisLanguageResolver(this.resolveSynthesisLanguage);
+
     log.info({ callSessionId }, "Media stream call session created");
   }
 
@@ -344,9 +356,16 @@ export class MediaStreamCallSession {
         );
       }
     } else {
+      // The gateway's close reason does not survive the relay (Bun's
+      // WebSocket client drops it), so tunnel loss is decoded from the
+      // dedicated close code.
       const detail =
         reason ||
-        (code ? `media_stream_closed_${code}` : "media_stream_closed_abnormal");
+        (code === GATEWAY_TUNNEL_LOST_WS_CLOSE_CODE
+          ? "public ingress tunnel disconnected"
+          : code
+            ? `media_stream_closed_${code}`
+            : "media_stream_closed_abnormal");
       updateCallSession(this.callSessionId, {
         status: "failed",
         endedAt: Date.now(),
@@ -673,6 +692,7 @@ export class MediaStreamCallSession {
       {
         assistantId: result.assistantId,
         trustContext: result.trustContext,
+        resolveSynthesisLanguage: this.resolveSynthesisLanguage,
       },
     );
     this.controller = controller;

package/src/calls/media-stream-stt-session.ts

@@ -48,6 +48,7 @@ import type {
   SttCallContextHints,
   SttStreamServerEvent,
 } from "../stt/types.js";
+import { baseLanguageSubtag } from "../util/language-subtag.js";
 import { getLogger } from "../util/logger.js";
 import {
   mulawToLinear,
@@ -220,6 +221,20 @@ export class MediaStreamSttSession {
   /** Speech-bearing audio milliseconds since the last streaming final. */
   private utteranceAudioMs = 0;
 
+  /**
+   * The dominant detected-language base subtag of the latest committed
+   * streaming final that carried language tags. Overwritten per
+   * utterance, matching live voice's per-utterance resolution, so a
+   * caller who switches languages retargets synthesis on their next
+   * utterance instead of having to outvote the session's history. Only
+   * finals that carry transcript text update it: silence finals can
+   * carry container-level tags describing no emitted words. Untagged
+   * finals keep the previous value; batch transcription reports no
+   * language tags, so it stays unset there and any streaming-detected
+   * value is cleared when the session settles on batch mode.
+   */
+  private latestUtteranceLanguage: string | undefined;
+
   constructor(
     config: MediaStreamSttSessionConfig = {},
     callbacks: MediaStreamSttSessionCallbacks = {},
@@ -304,6 +319,15 @@ export class MediaStreamSttSession {
     return this.startupFramesDroppedCount;
   }
 
+  /**
+   * The caller's detected language as of the latest tagged streaming
+   * final, as a lowercase base subtag. Undefined until a tagged final
+   * commits (batch mode, non-tagging providers, silence).
+   */
+  currentLanguage(): string | undefined {
+    return this.latestUtteranceLanguage;
+  }
+
   // ── Event handlers ─────────────────────────────────────────────────
 
   private handleStart(event: MediaStreamStartEvent): void {
@@ -477,6 +501,10 @@ export class MediaStreamSttSession {
    */
   private enterBatchMode(): void {
     this.mode = "batch";
+    // Batch transcripts carry no language metadata, so a language detected
+    // while streaming would otherwise hint synthesis for the rest of the
+    // call. Clear it so the configured pin (or no hint) takes over.
+    this.latestUtteranceLanguage = undefined;
     this.startupFrames = [];
     this.capabilityPromise ??= resolveTelephonySttCapability();
 
@@ -510,11 +538,28 @@ export class MediaStreamSttSession {
     switch (event.type) {
       case "partial":
         return;
+      case "finalized":
+        return;
+      case "turn-start":
+      case "eager-turn-end":
+      case "turn-resumed":
+      case "turn-end":
+        // The local VAD and the provider's boundary finals own turn
+        // taking. Listed case-by-case rather than under `default` so the
+        // exhaustiveness check flags this site when turn detection is
+        // wired in.
+        return;
       case "final": {
         const durationMs = Math.round(this.utteranceAudioMs);
         this.utteranceAudioMs = 0;
         const text = event.text.trim();
         if (text.length > 0) {
+          // `languages` is dominance-ranked, so the first entry is the
+          // utterance's dominant tag.
+          const dominant = baseLanguageSubtag(event.languages?.[0]);
+          if (dominant !== undefined) {
+            this.latestUtteranceLanguage = dominant;
+          }
           this.callbacks.onTranscriptFinal?.(text, durationMs);
         }
         return;
@@ -536,6 +581,10 @@ export class MediaStreamSttSession {
           this.enterBatchMode();
         }
         return;
+      default: {
+        const _exhaustive: never = event;
+        return;
+      }
     }
   }
 

package/src/calls/telephony-synthesis-language.ts

@@ -0,0 +1,84 @@
+/**
+ * Synthesis-language resolution for telephony TTS.
+ *
+ * The telephony call-control prompt instructs the model to speak the
+ * caller's language; this resolver produces the matching TTS hint so
+ * providers that can enforce a language render the reply in it (the hint
+ * is a no-op for providers that cannot). Resolution mirrors live voice's
+ * per-utterance turn language (live-voice-session.ts): the caller's
+ * latest STT-detected language when the transcriber tags finals, else a
+ * monolingual `services.stt.language` pin when the configured provider
+ * honors manual language selection, else undefined (no hint, provider
+ * default behavior).
+ */
+
+import { getConfig } from "../config/loader.js";
+import type { AssistantConfig } from "../config/types.js";
+import { pinnedListeningLanguage } from "../providers/speech-to-text/provider-catalog.js";
+import { resolveLanguageVoiceOverride } from "../tts/language-voices.js";
+import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
+import type { TtsProviderId } from "../tts/types.js";
+import { baseLanguageSubtag } from "../util/language-subtag.js";
+
+/**
+ * Resolve the language hint for telephony synthesis as a lowercase base
+ * subtag, or undefined when no signal resolves.
+ *
+ * @param detectedLanguage - The caller language the STT session detected
+ *   on its latest tagged utterance, when a session is reachable from the
+ *   call site. Wins over the pin whenever it normalizes to a non-empty
+ *   tag.
+ */
+export function resolveTelephonySynthesisLanguage(
+  detectedLanguage?: string,
+): string | undefined {
+  const detected = baseLanguageSubtag(detectedLanguage);
+  if (detected !== undefined) {
+    return detected;
+  }
+
+  let stt: { provider: string; language?: string };
+  try {
+    stt = getConfig().services.stt;
+  } catch {
+    // Config unavailable (early startup, minimal test workspaces): no hint.
+    return undefined;
+  }
+
+  return pinnedListeningLanguage(stt.provider, stt.language);
+}
+
+/**
+ * Resolve the per-language voice for a telephony synthesis request from
+ * the synthesizing provider's `services.tts.providers.<id>.languageVoices`
+ * map. Keyed by the provider actually synthesizing, which on the
+ * media-stream transport may be a playability fallback rather than the
+ * configured provider, because voice identifiers are provider-specific.
+ * Returns undefined (provider default voice) when the request carries no
+ * language, config is unavailable, or the provider's map has no entry.
+ */
+export function resolveTelephonyLanguageVoice(
+  providerId: string,
+  language: string | undefined,
+): string | undefined {
+  if (language === undefined) {
+    return undefined;
+  }
+
+  let config: AssistantConfig;
+  try {
+    config = getConfig();
+  } catch {
+    // Config unavailable (early startup, minimal test workspaces): no override.
+    return undefined;
+  }
+
+  const { providerConfig } = resolveTtsConfig(
+    config,
+    providerId as TtsProviderId,
+  );
+  return resolveLanguageVoiceOverride(
+    providerConfig.languageVoices as Record<string, string> | undefined,
+    language,
+  );
+}

package/src/calls/tts-text-sanitizer.ts

@@ -49,11 +49,18 @@ export function sanitizeForTts(text: string): string {
   result = result.replace(/^[-*]\s+/gm, "");
 
   // 7. Italic: *text* or _text_ → text
-  //    Word-boundary-aware with non-whitespace content edges, so arithmetic
-  //    like `5 * 3 and 4 * 2` and identifiers like `my_var` survive. Mirrors
-  //    the open-span rule in tts/speakable-segments.ts.
-  result = result.replace(/(?<!\w)\*([^\s*](?:[^*]*[^\s*])?)\*(?!\w)/g, "$1");
-  result = result.replace(/(?<!\w)_([^\s_](?:[^_]*[^\s_])?)_(?!\w)/g, "$1");
+  //    Word-boundary-aware (Unicode letters/digits, so café and 変数 count as
+  //    word chars) with non-whitespace content edges, so arithmetic like
+  //    `5 * 3 and 4 * 2` and identifiers like `my_var` survive. Mirrors the
+  //    open-span rule in tts/speakable-segments.ts.
+  result = result.replace(
+    /(?<![\p{L}\p{N}_])\*([^\s*](?:[^*]*[^\s*])?)\*(?![\p{L}\p{N}_])/gu,
+    "$1",
+  );
+  result = result.replace(
+    /(?<![\p{L}\p{N}_])_([^\s_](?:[^_]*[^\s_])?)_(?![\p{L}\p{N}_])/gu,
+    "$1",
+  );
 
   // 8. Emojis: strip extended pictographic characters, variation selectors,
   //    zero-width joiners, skin tone modifiers, and regional indicator symbols (flags).

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

@@ -17,6 +17,7 @@ import type {
 import { consumeGrantForInvocation } from "../approvals/approval-primitive.js";
 import type {
   ChannelId,
+  ClientOs,
   InterfaceId,
   TurnChannelContext,
   TurnInterfaceContext,
@@ -33,6 +34,7 @@ import {
   recordConversationPersistedSeq,
   updateMessageContent,
 } from "../persistence/conversation-crud.js";
+import { pinnedListeningLanguage } from "../providers/speech-to-text/provider-catalog.js";
 import type { ContentBlock } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
@@ -265,6 +267,22 @@ export interface VoiceTurnOptions {
   userMessageInterface?: InterfaceId;
   /** Source interface for persisted assistant messages. Defaults to userMessageInterface. */
   assistantMessageInterface?: InterfaceId;
+  /**
+   * Analytics attribution for a live-voice turn: which client opened the
+   * session, and that session's id. Persisted into the user message's
+   * `metadata.client` bag, which `turn-events-store` projects onto
+   * `TurnTelemetryEvent.client`, so a live-voice turn is countable per client
+   * and joinable to its session's start/end funnel rows.
+   *
+   * Deliberately separate from {@link userMessageInterface}: that field feeds
+   * `resolveChannelCapabilities` and decides what the turn may do, so it is not
+   * free to carry attribution. Absent for phone calls and for clients that send
+   * no identity on the start frame.
+   */
+  voiceTelemetry?: {
+    sessionId: string;
+    client?: ClientOs;
+  };
   /** Per-turn control prompt. Undefined uses the phone prompt; null disables it. */
   voiceControlPrompt?: string | null;
   /** The transcribed caller utterance or synthetic marker. */
@@ -389,18 +407,6 @@ export interface VoiceTurnHandle {
  * on a live phone call" framing (the session system prompt already
  * provides assistant identity) and guardian context (injected separately).
  */
-/**
- * Steering shared by every voice channel. A sign-in flow opens a browser
- * window mid-call that the caller may be unable to see or complete, whether it
- * is reached through a ui-surface tool or through shell and CLI tools (e.g.
- * `assistant oauth connect`). Tell the model to speak the limitation and defer
- * the flow to text chat instead.
- *
- * This outlives the ui-surface restriction it was written alongside: a
- * live-voice call can now show surfaces, but a browser window handing control
- * to a third party mid-call is a different problem, and one a minimized room
- * does not solve.
- */
 /**
  * How long a live-voice call waits on an approval before deciding it itself.
  *
@@ -411,8 +417,49 @@ export interface VoiceTurnHandle {
  */
 const VOICE_APPROVAL_TIMEOUT_MS = 45_000;
 
-export const VOICE_NO_SETUP_FLOWS_RULE =
-  "Never start account connections, OAuth or sign-in flows, or any other action that opens a browser window or needs the user's screen during this call — not even through shell or CLI tools. If the task needs one, say so briefly and offer to finish it in text chat after the call.";
+/**
+ * Telephony-only steering. A sign-in flow opens a browser window on a screen
+ * the caller does not have in front of them, whether it is reached through a
+ * ui-surface tool or through shell and CLI tools (e.g. `assistant oauth
+ * connect`). Tell the model to speak the limitation and defer the flow to text
+ * chat instead.
+ *
+ * Scoped to the phone because the screen is what decides it. A phone call has
+ * no screen, so the `open_url` signal a CLI tool can reach lands somewhere the
+ * caller will never see, and that signal bus carries no capability or
+ * conversation context, so this rule is the only thing standing in front of it
+ * here. A live-voice call is the opposite case: the user is holding the screen,
+ * and the room minimizes itself to hand it back (see
+ * LIVE_VOICE_SETUP_FLOW_TEACHING).
+ */
+const PHONE_NO_SETUP_FLOWS_RULE =
+  "Never start account connections, OAuth or sign-in flows, or any other action that opens a browser window or needs the user's screen during this call, not even through shell or CLI tools. If the task needs one, say so briefly and offer to finish it in text chat after the call.";
+
+/**
+ * The pre-speech tail of the speak-the-caller's-language rule. A monolingual
+ * `services.stt.language` pin is the strongest pre-speech signal of the
+ * caller's language (the transcriber is already listening in it, see
+ * media-stream-stt-session.ts and providers/speech-to-text/resolve.ts), so it
+ * outranks the English default; "multi" and unset mean auto-detect, where
+ * English remains the fallback. The pin only counts when the active provider
+ * honors manual language selection (see pinnedListeningLanguage):
+ * auto-detecting providers (gemini, whisper) ignore a persisted language
+ * entirely, so greeting in it would contradict what the transcriber
+ * actually hears. Exported for tests: the default test config exercises
+ * only the auto-detect branch.
+ */
+export function preSpeechLanguageRuleFragment(
+  sttLanguage: string | undefined,
+  sttProvider?: string,
+): string {
+  const configuredListeningLanguage =
+    sttProvider !== undefined
+      ? pinnedListeningLanguage(sttProvider, sttLanguage)
+      : undefined;
+  return configuredListeningLanguage
+    ? `use the language the Task context implies, if any; otherwise open in the assistant's configured listening language ("${configuredListeningLanguage}"), and default to English only when neither gives a language`
+    : "use the language the Task context implies, if any; otherwise default to English";
+}
 
 function buildVoiceCallControlPrompt(opts: {
   isInbound: boolean;
@@ -506,16 +553,17 @@ function buildVoiceCallControlPrompt(opts: {
     "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.`,
-    `12. ${VOICE_NO_SETUP_FLOWS_RULE}`,
+    `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, config.services.stt.provider)}.`,
+    `13. ${PHONE_NO_SETUP_FLOWS_RULE}`,
   );
 
   // Triage-and-escalate routing rules. The front-door leg decides and may
   // hand off; the escalated leg continues the answer after a holding phrase
   // was already spoken.
   if (opts.routingLeg === "front-door") {
-    lines.push(`13. ${frontDoorRuleWithDigest(opts.unifiedVerdict === true)}`);
+    lines.push(`14. ${frontDoorRuleWithDigest(opts.unifiedVerdict === true)}`);
   } else if (opts.routingLeg === "escalated") {
-    lines.push(`13. ${escalatedContinuationRule(opts.spokenEscalationBridge)}`);
+    lines.push(`14. ${escalatedContinuationRule(opts.spokenEscalationBridge)}`);
   }
 
   lines.push("</voice_call_control>");
@@ -945,6 +993,27 @@ export async function startVoiceTurn(
         // `isVoiceSessionUserMessage` for why the channel fields cannot carry it.
         voiceSessionTurn: true,
         ...(isHiddenSyntheticPrompt ? { hidden: true } : {}),
+        ...(opts.voiceTelemetry
+          ? {
+              // Projected onto `TurnTelemetryEvent.client` by
+              // `turn-events-store`. `voice_session_id` is what joins these
+              // turn rows to the session's funnel rows, so a session's turn
+              // count is a count of rows carrying its id, never a field
+              // anyone has to keep correct.
+              //
+              // `os` is the standard per-platform dimension the HTTP send
+              // path already fills from the same `detectClientOs()` value, so
+              // a voice turn reports its platform in the column existing turn
+              // analytics read rather than one only voice knows about.
+              client: {
+                voice: true,
+                voice_session_id: opts.voiceTelemetry.sessionId,
+                ...(opts.voiceTelemetry.client
+                  ? { os: opts.voiceTelemetry.client }
+                  : {}),
+              },
+            }
+          : {}),
       },
     });
     return persistResult.id;

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

@@ -26,6 +26,8 @@
  * cap/fallback policy. LiveVoiceSession drives the routing.
  */
 
+import { NON_LATIN_SENTENCE_ENDING_PUNCTUATION } from "../tts/speakable-segments.js";
+import { localizedOrDefault } from "../util/language-subtag.js";
 import {
   ESCALATE_VERDICT_TOKEN,
   HOLD_VERDICT_TOKEN,
@@ -57,6 +59,41 @@ export type VoiceRoutingLeg = "front-door" | "escalated";
 export const FALLBACK_ESCALATION_BRIDGE =
   "Let me think about that for a second.";
 
+/**
+ * Per-language spellings of the fallback escalation bridge, keyed by
+ * lowercased BCP 47 base subtag, covering the Deepgram code-switching roster
+ * (DEEPGRAM_MULTI_LANGUAGE_CODES in providers/speech-to-text/deepgram.ts).
+ * These are spoken audio; the English constant above also serves as the
+ * prompt exemplar and stays the default.
+ */
+export const FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE: Readonly<
+  Record<string, string>
+> = {
+  en: FALLBACK_ESCALATION_BRIDGE,
+  es: "Déjame pensarlo un segundo.",
+  fr: "Laissez-moi y réfléchir un instant.",
+  de: "Lass mich kurz darüber nachdenken.",
+  hi: "मुझे एक पल सोचने दीजिए।",
+  ru: "Дайте мне секунду подумать.",
+  pt: "Deixe-me pensar nisso um segundo.",
+  ja: "少し考えさせてください。",
+  it: "Fammi pensare un attimo.",
+  nl: "Laat me daar even over nadenken.",
+};
+
+/**
+ * The fallback escalation bridge in the caller's language: selected by the
+ * lowercased base subtag of `language` (e.g. "pt-BR" -> "pt"), defaulting to
+ * {@link FALLBACK_ESCALATION_BRIDGE} for unknown or absent languages.
+ */
+export function fallbackEscalationBridgeFor(language?: string): string {
+  return localizedOrDefault(
+    FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
+    language,
+    FALLBACK_ESCALATION_BRIDGE,
+  );
+}
+
 /**
  * Minimum length (after capping, trimmed) of the front-door leg's spoken
  * bridge for it to count as a real bridge. Below this, the fallback bridge
@@ -71,8 +108,17 @@ export const MIN_SPOKEN_BRIDGE_CHARS = 3;
  */
 export const MAX_ESCALATION_BRIDGE_CHARS = 140;
 
-/** Sentence terminators that end an escalation bridge. */
-const BRIDGE_SENTENCE_END_REGEX = /[.!?…]/;
+/**
+ * Sentence terminators that end an escalation bridge: the segmenter's
+ * non-Latin ender roster (tts/speakable-segments.ts) plus the ASCII enders
+ * and the ellipsis. Built from the shared set so the rosters cannot
+ * diverge: without the non-Latin enders a Japanese or Hindi bridge never
+ * hits a terminator and buffers to the char cap before hand-off. Exported
+ * for tests that assert spoken phrases end in a recognized terminator.
+ */
+export const BRIDGE_SENTENCE_END_REGEX = new RegExp(
+  `[.!?…${[...NON_LATIN_SENTENCE_ENDING_PUNCTUATION].join("")}]`,
+);
 
 /**
  * Normalize a raw post-`[1]` stream into the bridge that is actually
@@ -227,10 +273,10 @@ export function frontDoorDecisionRule(opts?: {
           // Hold requires positive evidence of an unfinished sentence, never
           // mere uncertainty, because the two mistakes cost differently. A
           // false hold is silent: the verdict, the extension window, and the
-          // replay dispatch all elapse with the thinking frame and ack
-          // deferred until commit, roughly tripling felt latency. A false
+          // replay dispatch all elapse before the turn commits, roughly
+          // tripling felt latency. A false
           // release only answers a beat early, which barge-in absorbs.
-          `- If the caller's words are visibly unfinished — a trailing conjunction, a dangling clause, a list still being dictated — output ONLY ${HOLD_VERDICT_TOKEN} and stop, no other text. Judge the words themselves: a complete question or statement means they are done, even when it is short or leans on earlier context ("What do you think?", "Why?", "And then?"). Never hold merely because more could follow.`,
+          `- If the caller's words are visibly unfinished (a trailing conjunction, a dangling clause, a list still being dictated) output ONLY ${HOLD_VERDICT_TOKEN} and stop, no other text. Judge the words themselves: a complete question or statement means they are done, even when it is short or leans on earlier context ("What do you think?", "Why?", "And then?"). Callers may speak any language: those examples are English exemplars only, and completeness is judged by the grammar of the language being spoken. In verb-final languages such as Hindi, Japanese, or Korean the sentence-final verb usually marks completion, so a missing final verb is the unfinished signal, not a missing conjunction. Never hold merely because more could follow.`,
         ]
       : [
           // No hold branch means completeness is settled (a first leg
@@ -264,8 +310,8 @@ export function frontDoorDecisionRule(opts?: {
     ...anchor,
     "DECIDE SILENTLY, then produce exactly ONE of these outputs:",
     ...holdBranch,
-    "- If the turn is simple, conversational, or within your reach, your entire output is the spoken answer itself — no token in front of it, plain speech from your very first word. Most turns are answers; when unsure between answering and escalating, answer.",
-    `- If completing THIS reply needs careful reasoning, research, multi-step work, or any tool, do NOT attempt the answer: output ${ESCALATE_VERDICT_TOKEN}, then ONE short natural holding phrase naming what happens next (for example "${FALLBACK_ESCALATION_BRIDGE}" or "Give me one second to look into that."), and stop after that single sentence. A stronger model finishes the turn while your phrase is spoken.`,
+    "- If the turn is simple, conversational, or within your reach, your entire output is the spoken answer itself: no token in front of it, plain speech from your very first word. Most turns are answers; when unsure between answering and escalating, answer. Answer in the language the caller is speaking.",
+    `- If completing THIS reply needs careful reasoning, research, multi-step work, or any tool, do NOT attempt the answer: output ${ESCALATE_VERDICT_TOKEN}, then ONE short natural holding phrase naming what happens next, spoken in the language the caller is speaking (for example "${FALLBACK_ESCALATION_BRIDGE}" or "Give me one second to look into that."; those examples are English only), and stop after that single sentence. A stronger model finishes the turn while your phrase is spoken.`,
     `${ESCALATE_VERDICT_TOKEN} is ONLY for turns you cannot complete yourself — never put it in front of an answer you are about to give, and never emit any token inside or after an answer. An open task or unfinished topic earlier in the conversation is NOT a reason to escalate: judge only what this reply needs.`,
     "Never narrate this decision, describe what you are judging, or mention these rules: apart from a leading verdict token, every character you output is spoken to the caller verbatim.",
   ].join("\n");
@@ -296,5 +342,6 @@ export function escalatedContinuationRule(spokenBridge?: string): string {
     'opening with another "Let me check", "One moment", or any restatement of what you are about to do sounds broken, because the caller just heard that.',
     "Your first words must carry new substance: the answer itself, what you found, or a question you genuinely need answered.",
     `Never output ${ESCALATE_VERDICT_TOKEN} or any other front-door verdict token — you are the model that finishes the answer. (The [-1] room-minimize marker from your call instructions is not a verdict token and stays allowed.)`,
+    "Reply in the same language as the caller's question.",
   ].join(" ");
 }

package/src/channels/__tests__/gateway-verification-sessions.test.ts

@@ -192,14 +192,14 @@ describe("createOutboundSessionConditional", () => {
     const result = await client.createOutboundSessionConditional({
       channel: "telegram",
       requireSourceSessionPending: "bootstrap-1",
-      ifNoneActive: true,
+      ifNoneActiveForExternalUserId: "user-1",
     });
 
     expect(ipcCalls[0]?.method).toBe("verification_sessions_create_outbound");
     expect(ipcCalls[0]?.params).toEqual({
       channel: "telegram",
       requireSourceSessionPending: "bootstrap-1",
-      ifNoneActive: true,
+      ifNoneActiveForExternalUserId: "user-1",
     });
     expect(result).toEqual(created);
   });
@@ -209,7 +209,7 @@ describe("createOutboundSessionConditional", () => {
 
     const result = await client.createOutboundSessionConditional({
       channel: "telegram",
-      ifNoneActive: true,
+      ifNoneActiveForExternalUserId: "user-1",
     });
 
     expect(result).toEqual({