@olares/lares-core 0.15.21 → 0.15.23

package/brand/identity.js

@@ -10,6 +10,11 @@ export const UPSTREAM_TITLE = "DeepSeek Harness";
 
 export const THEME_COLOR = "#6366F1";
 
+/** Letter-by-letter, so a model cannot drop the "a" and emit "olores". */
+function platformSpelling() {
+  return `Spell the platform name exactly ${PLATFORM_NAME} (${[...PLATFORM_NAME].join(", ")}).`;
+}
+
 export function replaceProductTitle(title) {
   return String(title ?? "").split(UPSTREAM_TITLE).join(PRODUCT_NAME);
 }
@@ -18,10 +23,11 @@ export function replaceProductTitle(title) {
 export function identityPrompt() {
   return [
     `You are ${PRODUCT_NAME}, a helpful assistant running on ${PLATFORM_NAME}.`,
+    platformSpelling(),
     `Prefer olares-cli for ${PLATFORM_NAME} platform tasks when skills apply.`,
     `olares-cli is on PATH and already signed in as the user: ${PLATFORM_NAME} mounts this application's credential into the container. Never run profile login or profile import — a platform-issued profile refuses both.`,
     "For image, video, audio, or 3D generation, creation, or image editing — including FlowStudio scenes and workflows (T2V, I2V, R2V) — follow the lares-media-create skill: list that family on Router, then call media_generate, which waits for the result and publishes it. Do not curl FlowStudio. Do not diagnose Router or sync catalogs unless that list is empty.",
-    "Use read/write/edit for files; use background jobs for long shell work.",
+    "To answer a question or look something up, only read: use read, search, and read-only commands such as olares-cli. Do not use write or edit to look something up, take notes, or try a change the user did not ask for. Use write or edit only when the user asked you to change or produce that file, and prefer them over shell for that file work. Use background jobs for long shell work.",
     "User-visible files belong in the session workspace (cwd) as relative paths. Do not write them under /app: that is the application overlay, and the chat preview cannot open it.",
     "For the current date or time, run `date`; the process TZ is the user's configured Olares time zone.",
     "Images the user attaches are already in context; read_image is only for image files that exist on disk, never for an attachment.",
@@ -40,6 +46,7 @@ export function surfacePrompt(webUrl) {
     `You are interacting with the user through ${PRODUCT_NAME} at ${webUrl}.`,
     `When the user refers to "this page", "this GUI", or "this app" without naming another target, they mean ${PRODUCT_NAME}.`,
     "The browser provides no implicit DOM, route, or screenshot context.",
+    platformSpelling(),
     `If asked who you are, answer as ${PRODUCT_NAME} on ${PLATFORM_NAME}.`,
   ].join(" ");
 }
@@ -54,7 +61,9 @@ You are helping inside an ${PLATFORM_NAME} workspace via ${PRODUCT_NAME}.
 - For image / video / audio / 3D generation, including FlowStudio scenes and workflows, follow the lares-media-create skill: list that family, POST the matching Router shim route, land the file. Do not curl FlowStudio.
 - Stay inside the workspace for file edits unless the user explicitly asks otherwise.
 - Write files the user should open as workspace-relative paths (session cwd). \`/app\` is the running application and is not previewable.
-- Prefer structured fs tools (read / write / edit) over shell for file work.
+- To look something up, only read. Do not use write or edit to look something up, take notes, or try a change the user did not ask for.
+- Use write or edit only when the user asked you to change or produce that file. Prefer those tools over shell for that file work.
+- ${platformSpelling()}
 - Long-running shell work can use background jobs; check results with job_output.
 - \`@path\` in a user message is workspace-relative, not absolute; \`/id\` names a skill.
 - If asked who you are, you are ${PRODUCT_NAME} on ${PLATFORM_NAME}.
@@ -67,6 +76,20 @@ export const LEGACY_AGENTS_SEEDS = [
 
 You are helping inside an Olares workspace via Lares.
 
+- Prefer olares-cli skills for platform tasks (market, cluster, files, router, …).
+- olares-cli is already signed in as the user from the credential Olares mounts into this container. Never run \`profile login\` or \`profile import\`; a platform-issued profile refuses both.
+- For image / video / audio / 3D generation, including FlowStudio scenes and workflows, follow the lares-media-create skill: list that family, POST the matching Router shim route, land the file. Do not curl FlowStudio.
+- Stay inside the workspace for file edits unless the user explicitly asks otherwise.
+- Write files the user should open as workspace-relative paths (session cwd). \`/app\` is the running application and is not previewable.
+- Prefer structured fs tools (read / write / edit) over shell for file work.
+- Long-running shell work can use background jobs; check results with job_output.
+- \`@path\` in a user message is workspace-relative, not absolute; \`/id\` names a skill.
+- If asked who you are, you are Lares on Olares.
+`,
+  `# AGENTS.md
+
+You are helping inside an Olares workspace via Lares.
+
 - Prefer olares-cli skills for platform tasks (market, cluster, files, router, …).
 - For image / video / audio / 3D generation, including FlowStudio scenes and workflows, follow the lares-media-create skill: list that family, POST the matching Router shim route, land the file. Do not curl FlowStudio.
 - Stay inside the workspace for file edits unless the user explicitly asks otherwise.

package/i18n/voice.js

@@ -105,6 +105,7 @@ export const ZH = {
   "call.start": "语音对话",
   "call.end": "结束语音",
   "call.resume": "恢复语音",
+  "call.restart": "重新开始",
   "call.stopPlayback": "停止朗读",
   "call.cancelTask": "取消任务",
   "call.listening": "正在收听",
@@ -387,6 +388,7 @@ export const EN = {
   "call.start": "Voice conversation",
   "call.end": "End voice",
   "call.resume": "Resume voice",
+  "call.restart": "Start again",
   "call.stopPlayback": "Stop speaking",
   "call.cancelTask": "Cancel task",
   "call.listening": "Listening",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.21",
+  "version": "0.15.23",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {

package/router/catalog.d.ts

@@ -14,7 +14,7 @@ export interface RouterCatalogRow {
   reasoningDefault?: string;
   /** Tokens one request may span, or null when Router states none. */
   contextWindow: number | null;
-  /** Output tokens a turn may reserve: Router's limit capped at a quarter of the window. */
+  /** Output tokens a turn may reserve: Router's limit capped at a tenth of the window. */
   maxTokens: number | null;
 }
 

package/router/catalog.js

@@ -42,13 +42,14 @@ function tokenCount(value) {
 /**
  * Output tokens a turn may ask for. A local engine reports its whole context
  * as max_output_tokens, and a request that reserves all of it cannot fit
- * beside its own prompt: the engine's KV budget refuses it or, worse, admits
- * it and evicts every other request. A quarter of the window leaves room for
- * the prompt and still exceeds any reply a chat turn writes.
+ * beside its own prompt. Compaction subtracts this cap from the model's
+ * context window before the 80% pressure line, so the cap has to fit in the
+ * remaining fifth or that line never fires. A tenth of the window does, once
+ * the summary headroom (8192) is counted, for any window of at least 80k.
  */
 export function outputTokenBudget(declared, contextWindow) {
   if (contextWindow === null) return declared;
-  const cap = Math.max(1, Math.floor(contextWindow / 4));
+  const cap = Math.max(1, Math.floor(contextWindow / 10));
   return declared === null ? cap : Math.min(declared, cap);
 }
 

package/voice/controller.js

@@ -107,6 +107,7 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
     bindSession(sessionId) { if (sessionId) change({ sessionId }); },
     subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
     async start({ sessionId = null, continuous = false, running = false, manual = false, shouldStart = () => true } = {}) {
+      output.arm?.();
       manualTurns = manual;
       const startedEpoch = ++epoch;
       creating = null;

package/voice/conversation.js

@@ -1,8 +1,21 @@
+import { primePlaybackContext } from "./pcm-player.js";
 import { createVoiceController } from "./controller.js";
 import { createDeviceInput } from "./device-input.js";
 import { createHostInput } from "./host-input.js";
 import { mintRpcId } from "../larepass/rpc.js";
 
+/** Bound a request without requiring AbortSignal.any / timeout, which some mobile webviews lack. */
+function outputSignal(abort) {
+  const signals = [abort.signal];
+  if (typeof AbortSignal?.timeout === "function") {
+    try { signals.push(AbortSignal.timeout(10_000)); } catch { /* the caller signal still cancels the request */ }
+  }
+  if (signals.length > 1 && typeof AbortSignal.any === "function") {
+    try { return AbortSignal.any(signals); } catch { /* same */ }
+  }
+  return abort.signal;
+}
+
 export function createVoiceConversation({ request, transcribe, playback, onReply = () => {}, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, backend, presentationSession = false, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, input: inputPort, captureConfig, streamInput, preparation }) {
   const voiceId = mintRpcId();
   const headers = { "x-lares-voice-id": voiceId, "x-lares-voice-device": device };
@@ -34,7 +47,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
   const controller = createVoiceController({ voiceId, input, idleTimeoutMs, recoveryTimeoutMs, onExpired: () => stop(), onTranscript: onTranscript ? async (value) => { await onTranscript(value); if (!continuous) await stop(); } : null, metric: (event) => {
     metric(event);
     void call("/session/metric", { stage: event.stage, durationMs: event.durationMs }).catch(() => {});
-  }, output: { get canPause() { return playback.canPause === true; }, key: () => playback.key, pause: () => playback.pause?.(), resume: () => playback.resume?.(), async stop() {
+  }, output: { arm() { primePlaybackContext(); }, get canPause() { return playback.canPause === true; }, key: () => playback.key, pause: () => playback.pause?.(), resume: () => playback.resume?.(), async stop() {
       const reply = lastUtterance;
       playback.stop();
       if (!reply || !Number.isFinite(reply.turn) || typeof lastSessionId !== "string") return;
@@ -154,7 +167,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
         if (error) throw error;
         const abort = outputAbort = new AbortController();
         try {
-          await call("/session/output", { readAloud: next }, AbortSignal.any([abort.signal, AbortSignal.timeout(10_000)]));
+          await call("/session/output", { readAloud: next }, outputSignal(abort));
           if (!disposed && revision === outputRevision) confirmedReadAloud = next;
         } catch (error) {
           if (!disposed && revision === outputRevision) {

package/voice/panel.js

@@ -2,7 +2,7 @@ import { setVoiceActivity } from "./activity.js";
 import { DICTATION_PRESETS } from "./dictation.js";
 
 /** The panel owns drafts and turn policy; adapters only supply settings, audio and insertion ports. */
-export function createVoicePanel({ create, complete, loadConfig = async () => ({}), process = async ({ text }) => text, onSession = () => {}, manualTurns = true, inlineDictation = false, prepareInput = () => null }) {
+export function createVoicePanel({ create, complete, loadConfig = async () => ({}), process = async ({ text }) => text, onSession = () => {}, manualTurns = true, inlineDictation = false, prepareInput = () => null, armOutput = () => {} }) {
   let state = { visible: false, inputActive: false, previewVisible: false, mode: "single", sessionId: null, raw: "", draft: "", edited: false, preset: "raw", stage: "idle", snapshot: null, busy: false, error: null, readAloudError: null, device: "", levels: [], startedAt: null, elapsedMs: 0, holding: false, cancelArmed: false };
   let call = null, config = null, generation = 0, intent = 0, processing = null;
   let inputPreparation = null;
@@ -56,7 +56,11 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     }
   };
   const prepare = async (token) => {
-    if (call?.controller.getSnapshot().connection === "paused") { await call.resume({ shouldResume: () => token === intent && state.visible }); return; }
+    if (call?.controller.getSnapshot().connection === "paused") {
+      await call.resume({ shouldResume: () => token === intent && state.visible });
+      if (token === intent && state.visible && state.mode === "continuous" && typeof readAloudPreference === "boolean") await panel.setReadAloud(readAloudPreference);
+      return;
+    }
     if (call?.controller.getSnapshot().connection === "open") return;
     await end(); config = state.mode === "single" && config ? config : structuredClone(await loadConfig());
     if (token !== intent || !state.visible) return;
@@ -87,7 +91,11 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
   };
   const pause = async () => {
     try { if (state.mode === "single") { await finishCapture(); renderDraft(); } else await call?.controller.cancelRecording(); }
-    finally { if (call?.controller.getSnapshot().connection === "open") await call.pause(); }
+    finally {
+      if (call?.controller.getSnapshot().connection === "open") await call.pause();
+      // The banner belongs to the open call. Leaving it must not keep a mute/sync notice on the chat.
+      if (!state.visible) { outputRevision++; emit({ readAloudError: null }); }
+    }
   };
   const insertDraft = async () => {
     if (!state.draft || state.stage !== "preview") return;
@@ -108,6 +116,10 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
       if (!readAloudPending && appliedReadAloud === next && !state.readAloudError) return Promise.resolve(true);
       const revision = ++outputRevision;
       const current = () => target === call && epoch === generation && revision === outputRevision;
+      // Phone playback is local. Asking for silence already stopped it, so a missed
+      // server ack is not a readout failure. A headset can keep playing until the host agrees.
+      const localSilence = next !== true && state.device !== "headset";
+      if (localSilence) emit({ readAloudError: null });
       const pending = { target, value: next, promise: null };
       pending.promise = Promise.resolve().then(() => {
         if (target !== call || epoch !== generation) return;
@@ -116,14 +128,18 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
         if (current()) { appliedReadAloud = next; emit({ readAloudError: null }); }
         return true;
       }, error => {
-        if (current()) emit({ readAloudError: error.code || error.message || "voice_failed" });
+        if (!current()) return false;
+        if (localSilence) { appliedReadAloud = false; emit({ readAloudError: null }); return true; }
+        emit({ readAloudError: error.code || error.message || "voice_failed" });
         return false;
       }).finally(() => { if (readAloudPending === pending) readAloudPending = null; });
       readAloudPending = pending;
       return pending.promise;
     },
-    retryReadAloud() { return panel.setReadAloud(readAloudPreference); },
+    retryReadAloud() { armOutput(); return panel.setReadAloud(readAloudPreference); },
+    arm() { armOutput(); },
     open({ mode = state.mode, sessionId = state.sessionId, preset, configSnapshot } = {}) {
+      armOutput();
       if (state.busy) return Promise.resolve();
       cancelPreparation();
       const snapshot = configSnapshot ? structuredClone(configSnapshot) : null;
@@ -148,7 +164,7 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     },
     close() { intent++; cancelPreparation(); cancelProcessing(); emit({ visible: false, holding: false, cancelArmed: false }); if (state.mode === "continuous") void call?.controller.cancelRecording(); return enqueue(pause); },
     pause() { intent++; cancelPreparation(); cancelProcessing(); emit({ holding: false, cancelArmed: false }); if (state.mode === "continuous") void call?.controller.cancelRecording(); return enqueue(pause); },
-    start() { const token = ++intent; return enqueue(() => prepare(token)); },
+    start() { armOutput(); const token = ++intent; return enqueue(() => prepare(token)); },
     finish() {
       if (state.busy) return Promise.resolve();
       const token = intent;
@@ -168,6 +184,7 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
       return enqueue(async () => { await transform(preset); return true; });
     },
     holdStart() {
+      armOutput();
       if (state.busy || state.holding || state.snapshot?.capture === "transcribing") return Promise.resolve();
       const token = ++intent; emit({ holding: true, cancelArmed: false });
       return enqueue(async () => {

package/voice/pcm-player.js

@@ -1,21 +1,61 @@
 import { PCM_PLAYER_WORKLET } from "./pcm-worklet.js";
 import { pcmSamples } from "./realtime-audio.js";
 
+let primed = null;
+const worklets = new WeakMap();
+
+function ensureWorklet(ctx) {
+  const pending = worklets.get(ctx);
+  if (pending) return pending;
+  const url = URL.createObjectURL(new Blob([PCM_PLAYER_WORKLET], { type: "text/javascript" }));
+  let tracked;
+  tracked = Promise.resolve(ctx.audioWorklet.addModule(url)).finally(() => URL.revokeObjectURL(url)).catch((error) => {
+    if (worklets.get(ctx) === tracked) worklets.delete(ctx);
+    throw error;
+  });
+  worklets.set(ctx, tracked);
+  return tracked;
+}
+
+/** Create and resume the playback context inside the gesture that asked for sound. */
+export function primePlaybackContext(Context = globalThis.AudioContext || globalThis.webkitAudioContext) {
+  if (!Context) return null;
+  if (!primed || primed.state === "closed") primed = new Context();
+  const resume = primed.resume?.();
+  if (resume && typeof resume.catch === "function") resume.catch(() => {});
+  ensureWorklet(primed).catch(() => {});
+  return primed;
+}
+
 export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () => {}, context: Context = globalThis.AudioContext || globalThis.webkitAudioContext } = {}) {
-  let context, node, resolve, reject, played = 0, generation = 0, pendingByte = null, failed = null, paused = false;
+  let context, node, resolve, reject, played = 0, generation = 0, pendingByte = null, failed = null, paused = false, owned = false;
   const stop = () => {
     generation++; paused = false; node?.disconnect(); if (node) node.port.onmessage = null; node = null;
-    if (context && context.state !== "closed") void context.close().catch(() => {}); context = null; resolve?.(); resolve = reject = null; pendingByte = null;
+    const closing = owned ? context : null;
+    owned = false;
+    if (closing && closing.state !== "closed") void closing.close().catch(() => {});
+    context = null; resolve?.(); resolve = reject = null; pendingByte = null;
   };
   return {
     async start({ sampleRate, channels, encoding }) {
       stop(); failed = null; played = 0;
       if (!Context || channels !== 1 || encoding !== "pcm_s16le" || !Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) throw new Error("voice_audio_format");
       const epoch = generation;
-      context = new Context(); const opened = context;
-      const url = URL.createObjectURL(new Blob([PCM_PLAYER_WORKLET], { type: "text/javascript" }));
-      try { await opened.audioWorklet.addModule(url); await opened.resume(); } finally { URL.revokeObjectURL(url); }
-      if (epoch !== generation) { await opened.close().catch(() => {}); throw new Error("voice_cancelled"); }
+      const shared = primed && primed.state !== "closed" ? primed : null;
+      owned = !shared;
+      context = shared || new Context(); const opened = context;
+      try {
+        await ensureWorklet(opened);
+        await opened.resume?.();
+        if (epoch !== generation) throw new Error("voice_cancelled");
+        if (opened.state && opened.state !== "running") throw new Error("voice_playback_failed");
+        onMetric({ stage: "playback_context", state: opened.state || "unknown", shared: Boolean(shared) });
+      } catch (error) {
+        onMetric({ stage: "playback_context", state: opened.state || "missing", shared: Boolean(shared), code: error?.message || "voice_playback_failed" });
+        if (owned && opened.state !== "closed") void opened.close?.().catch(() => {});
+        owned = false; context = null;
+        throw error;
+      }
       node = new AudioWorkletNode(opened, "lares-pcm-player", { processorOptions: { inputRate: sampleRate }, numberOfInputs: 0, numberOfOutputs: 1, outputChannelCount: [1] });
       node.port.onmessage = ({ data }) => {
         if (epoch !== generation) return;

package/voice/presentation.js

@@ -6,12 +6,29 @@ export function voicePanelPresentation(view) {
   const preview = view.mode === "single" && ["preview", "processing"].includes(view.stage);
   const preparing = view.busy || capture === "recording" && view.snapshot?.inputReady === false;
   const recording = capture === "recording" && !preparing;
-  const error = view.error || view.snapshot?.error;
+  const reported = view.error || view.snapshot?.error;
+  // A muted call is not a listen session. "Resume to listen again" is the readout copy.
+  const error = reported === "voice_disconnected" && view.snapshot?.outputMuted ? "voice_background" : reported;
   const phase = view.cancelArmed ? "cancel" : error ? "error" : processing ? "processing" : transcribing ? "transcribing" : preparing ? "preparing" : recording ? "recording" : preview ? "preview" : view.snapshot && view.snapshot.playback !== "idle" ? "speaking" : view.snapshot?.agent === "running" ? "working" : "waiting";
   const status = error ? `error.${error}` : ({ cancel: "gesture.cancelRelease", processing: "dictation.processing", transcribing: "mic.transcribing", preparing: "mic.preparing", recording: "call.listening", preview: "dictation.preview", speaking: "dictation.speaking", working: "call.working", waiting: view.mode === "continuous" ? "gesture.waiting" : "dictation.preview" })[phase];
   return { phase, status, preview, recording, pending: processing || transcribing || preparing, error };
 }
 
+const RESTART_ERRORS = new Set(["voice_recovery_expired", "voice_idle_timeout"]);
+
+/**
+ * A continuous call that has failed is one composer banner.
+ * The session can still be resumed while it is paused; once the recovery
+ * window has closed, the only way back is a new call.
+ */
+export function voiceCallFailure(view) {
+  if (!view?.visible || view.mode !== "continuous") return null;
+  const ui = voicePanelPresentation(view);
+  if (!ui.error) return null;
+  const recoverable = view.snapshot?.connection === "paused" && !RESTART_ERRORS.has(ui.error);
+  return { code: ui.error, action: recoverable ? "resume" : "restart" };
+}
+
 /** Shared inline labels; clients own focus, positioning and the timer tick. */
 export function voiceInputPresentation(view, now = Date.now()) {
   const ui = voicePanelPresentation(view);

package/voice/stream-client.js

@@ -35,7 +35,19 @@ export async function playAudioStream(options) {
   const connection = await openAudioStream({ ...options, operation: "tts" });
   if (!connection) throw new Error("voice_stream_failed");
   const file = createBrowserPlayer();
-  const player = createPcmStreamPlayer({ onProgress: (frames) => { if (connection.readyState === 1) connection.send(JSON.stringify({ type: "progress", frames })); },
+  let progressNoted = false, progressBlocked = false;
+  const player = createPcmStreamPlayer({ onProgress: (frames) => {
+    if (connection.readyState !== 1) {
+      if (!progressBlocked) { progressBlocked = true; streamMetric(options, { stage: "playback_progress_blocked", readyState: connection.readyState, frames }); }
+      return;
+    }
+    try { connection.send(JSON.stringify({ type: "progress", frames })); }
+    catch (error) {
+      if (!progressBlocked) { progressBlocked = true; streamMetric(options, { stage: "playback_progress_blocked", code: error?.message || "send_failed", frames }); }
+      return;
+    }
+    if (!progressNoted) { progressNoted = true; streamMetric(options, { stage: "playback_progress_sent", frames }); }
+  },
     onMetric: (event) => { if (event.stage === "playback_started") options.onStatus?.("playing"); streamMetric(options, { ...event, durationMs: Date.now() - started }); } });
   let chain = Promise.resolve(), complete = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
   options.controls?.({
@@ -45,7 +57,14 @@ export async function playAudioStream(options) {
   });
   try {
     await new Promise((resolve, reject) => {
-      const fail = (error) => { reject(error); connection.close(); };
+      let failureLogged = false;
+      const noteFailure = (error) => {
+        const code = error?.message || "voice_playback_failed";
+        if (failureLogged || code === "voice_cancelled") return;
+        failureLogged = true;
+        streamMetric(options, { stage: "playback_failed", code, durationMs: Date.now() - started });
+      };
+      const fail = (error) => { noteFailure(error); reject(error); connection.close(); };
       const cancelled = () => { player.stop(); file.stop(); fail(new Error("voice_cancelled")); };
       options.signal?.addEventListener("abort", cancelled, { once: true });
       connection.addEventListener("message", ({ data }) => {
@@ -65,8 +84,12 @@ export async function playAudioStream(options) {
           else if (event.type === "done") { await player.finish(); complete = true; resolve(); }
         }).catch(fail);
       });
-      connection.addEventListener("error", () => fail(new Error("voice_disconnected")), { once: true });
-      connection.addEventListener("close", () => { options.signal?.removeEventListener("abort", cancelled); if (!complete) reject(new Error("voice_disconnected")); }, { once: true });
+      const dropped = () => new Error(options.signal?.aborted ? "voice_cancelled" : "voice_disconnected");
+      connection.addEventListener("error", () => fail(dropped()), { once: true });
+      connection.addEventListener("close", () => {
+        options.signal?.removeEventListener("abort", cancelled);
+        if (!complete) { const error = dropped(); noteFailure(error); reject(error); }
+      }, { once: true });
       if (options.signal?.aborted) cancelled();
     });
     return true;
@@ -101,8 +124,9 @@ export async function startTranscriptionStream(options) {
       else if (event.type === "error") fail(new Error(event.code));
     } catch { fail(new Error("voice_stream_failed")); }
   });
-  connection.addEventListener("close", () => fail(new Error("voice_disconnected")), { once: true });
-  connection.addEventListener("error", () => fail(new Error("voice_disconnected")), { once: true });
+  const dropped = () => fail(new Error(options.signal?.aborted ? "voice_cancelled" : "voice_disconnected"));
+  connection.addEventListener("close", dropped, { once: true });
+  connection.addEventListener("error", dropped, { once: true });
   if (options.signal?.aborted) fail(new Error("voice_cancelled"));
   await ready;
   return {

package/voice/stream-gateway.js

@@ -54,7 +54,11 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
         const started = Date.now();
         const send = (value) => { if (client.readyState === 1) client.send(JSON.stringify(value)); };
         const close = () => { if (closing) return; closing = true; abort.abort(); waiter?.(); fileDone?.(); clearTimeout(lifetime); upstream?.terminate(); clients.delete(client); client.close(); };
-        const error = (cause) => { send({ type: "error", code: cause.code || "voice_stream_failed" }); close(); };
+        const error = (cause) => {
+          const code = cause?.code || "voice_stream_failed";
+          if (grant.operation === "tts" && code !== "voice_cancelled") metric({ stage: "playback_stop", voiceId: grant.scope.id, code, sentFrames, playedFrames });
+          send({ type: "error", code }); close();
+        };
         const lifetime = setTimeout(() => error(fault("voice_timeout")), 180000);
         client.on("close", close); client.on("error", close);
         client.on("message", (raw, binary) => {
@@ -77,7 +81,9 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
               if (frame.type === "resume") { pausedAt = 0; waiter?.(); waiter = null; return; }
               if (frame.type === "file.done" && fileDone) { fileDone(); fileDone = null; return; }
               if (frame.type !== "progress" || !Number.isSafeInteger(frame.frames) || frame.frames < playedFrames || frame.frames > sentFrames) throw fault("voice_stream_state");
+              const firstProgress = playedFrames === 0 && frame.frames > 0;
               playedFrames = frame.frames; waiter?.(); waiter = null;
+              if (firstProgress) metric({ stage: "playback_progress", voiceId: grant.scope.id, frames: playedFrames });
             }
           } catch (cause) { error(cause); }
         });
@@ -110,6 +116,7 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
             waiter = wake;
             abort.signal.addEventListener("abort", wake, { once: true });
           });
+          let reportedWait = false;
           const pump = async () => {
             while (!abort.signal.aborted) {
               if (cursor >= run.events.length) {
@@ -129,6 +136,7 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
                 if (!rate) throw fault("voice_audio_format", 502);
                 for (let offset = 0; offset < event.chunk.length; offset += 16384) {
                   while (pausedAt || sentFrames - playedFrames > rate * 2 || client.bufferedAmount > 128 * 1024) {
+                    if (!reportedWait) { reportedWait = true; metric({ stage: "playback_wait", voiceId: grant.scope.id, sentFrames, playedFrames, paused: Boolean(pausedAt) }); }
                     await new Promise((resolve, reject) => { const timer = setTimeout(() => { waiter = null; reject(fault(pausedAt ? "voice_interruption_timeout" : "voice_audio_backpressure")); }, pausedAt ? Math.max(1, 10000 - (Date.now() - pausedAt)) : 10000); waiter = () => { clearTimeout(timer); resolve(); }; });
                     if (abort.signal.aborted || client.readyState !== 1) throw fault("voice_cancelled");
                   }