@olares/lares-core 0.15.30 → 0.15.32

package/i18n/voice.js

@@ -4,6 +4,7 @@ export const ZH = {
   "tts.default": "模型默认",
   "tts.loading": "正在加载音色…",
   "tts.loadFailed": "音色加载失败，请重试",
+  "tts.stale": "这次没能刷新音色，显示的是上次成功加载的列表。",
   "tts.noPresets": "此模型不提供预设音色，使用模型默认声音。",
   "tts.preview": "试听",
   "tts.stopPreview": "停止试听",
@@ -314,6 +315,7 @@ export const EN = {
   "tts.default": "Model default",
   "tts.loading": "Loading voices…",
   "tts.loadFailed": "Could not load voices. Try again.",
+  "tts.stale": "Could not refresh voices; showing the last list that loaded.",
   "tts.noPresets": "This model has no preset voices. Its default voice will be used.",
   "tts.preview": "Preview voice",
   "tts.stopPreview": "Stop preview",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.30",
+  "version": "0.15.32",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {
@@ -115,6 +115,7 @@
     "./voice/stream-client": "./voice/stream-client.js",
     "./voice/pcm-player": "./voice/pcm-player.js",
     "./voice/pcm-worklet": "./voice/pcm-worklet.js",
+    "./voice/wake-lock": "./voice/wake-lock.js",
     "./voice/config": "./voice/config.js",
     "./voice/languages": "./voice/languages.js",
     "./voice/service": "./voice/service.js",

package/voice/pcm-player.js

@@ -135,6 +135,9 @@ export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () =>
     pause() { paused = true; node?.port.postMessage({ type: "pause" }); },
     resume() { paused = false; node?.port.postMessage({ type: "resume" }); },
     get paused() { return paused; },
+    /** The browser's own view; a phone can report "running" while the OS has muted it. */
+    contextState: () => context?.state || "missing",
+    sampleRate: () => context?.sampleRate || 0,
     playedFrames: () => played,
     stop,
   };

package/voice/speech.js

@@ -134,19 +134,24 @@ export function matchSpeechEvent(event) {
 export function createReplySpeaker() {
   let armed = false;
   let skipKey = null;
+  // The answer that was already on screen when a turn opened is history. A new
+  // turn can deliver its first text in the same snapshot that reports the turn,
+  // and that text must still be read: the old code skipped it by its own key.
+  let lastKey = null;
   return {
     /** @returns {Utterance | null} the utterance to follow now, or null */
     observe({ sessionChanged, wasRunning, running, utterance }) {
       if (sessionChanged) {
         armed = Boolean(running);
-        skipKey = utterance?.key ?? null;
+        skipKey = lastKey = utterance?.key ?? null;
         return null;
       }
       if (!wasRunning && running) {
         armed = true;
-        skipKey = utterance?.key ?? null;
+        skipKey = lastKey;
       }
       const follow = armed && utterance && utterance.key !== skipKey ? utterance : null;
+      if (utterance?.key) lastKey = utterance.key;
       if (!running) armed = false;
       return follow;
     },
@@ -324,6 +329,26 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
     get canPause() { return current?.controls?.canPause === true; },
     pause() { if (!current?.controls?.canPause) return false; current.controls.pause(); emitOutput({ key: current.key, status: "confirming" }); return true; },
     resume() { if (!current?.controls?.canPause) return false; current.controls.resume(); emitOutput({ key: current.key, status: "playing" }); return true; },
+    /**
+     * Stop the current audio without marking the answer read. A voice take
+     * that is cancelled must be able to bring the same answer back; a take
+     * that is submitted consumes it instead.
+     */
+    suspend() {
+      if (!current) return null;
+      const key = current.key;
+      const source = current.source;
+      // `follow` marks a key as read when it starts. A cancelled voice take
+      // must be able to follow the same key again, so undo that mark here.
+      if (key != null) consumed.delete(key);
+      stop();
+      silence(source);
+      return key;
+    },
+    /** Mark an answer read without playing it (a voice take owns it now). */
+    consume(key) {
+      mark(consumed, key);
+    },
     stop() {
       if (!current) return;
       mark(consumed, current.key);

package/voice/stream-client.js

@@ -30,74 +30,195 @@ function streamMetric(options, event) {
   });
 }
 
+/**
+ * What a phone-side failure needs next to the frames: a WebView can keep
+ * reporting a running context while the app is hidden or the OS muted it, so
+ * the page and platform state travel with the metric.
+ */
+function clientFacts() {
+  const nav = globalThis.navigator || {};
+  return {
+    visibility: String(globalThis.document?.visibilityState || "unknown").slice(0, 16),
+    hidden: globalThis.document?.hidden === true,
+    platform: String(nav.userAgentData?.platform || nav.platform || "").slice(0, 40),
+    ua: String(nav.userAgent || "").slice(0, 180),
+  };
+}
+
+const RECONNECT_ATTEMPTS = 3;
+const RECONNECT_DELAY_MS = 400;
+
+/** A phone can lose the socket (lock screen, app switch, Wi-Fi/cellular) mid-answer. */
+function reconnectable(error) {
+  const code = error?.message;
+  return code === "voice_disconnected";
+}
+
 export async function playAudioStream(options) {
   const started = Date.now();
-  const connection = await openAudioStream({ ...options, operation: "tts" });
-  if (!connection) throw new Error("voice_stream_failed");
-  const file = createBrowserPlayer();
-  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, ending = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
+  const attempts = Math.max(1, Number(options.reconnectAttempts) || RECONNECT_ATTEMPTS);
+  const reconnectDelay = Number.isFinite(options.reconnectDelayMs) ? Math.max(0, options.reconnectDelayMs) : RECONNECT_DELAY_MS;
+  // Frames already rendered before the current socket. A reconnected socket
+  // replays the answer from its first segment; dropping this prefix keeps the
+  // listener where the dropped connection left off.
+  let skipFrames = 0;
+  let lastError = null;
+  let paused = false;
+  const controls = { player: null, connection: null, file: null, ready: false };
   options.controls?.({
-    get canPause() { return ready; },
-    pause() { if (!ready || paused) return; paused = true; player.pause(); file.pause(); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "pause" })); },
-    resume() { if (!ready || !paused) return; paused = false; player.resume(); void file.resume()?.catch(() => connection.close()); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "resume" })); },
+    get canPause() { return controls.ready; },
+    pause() {
+      if (!controls.ready || paused) return;
+      paused = true; controls.player?.pause(); controls.file?.pause();
+      if (controls.connection?.readyState === 1) controls.connection.send(JSON.stringify({ type: "pause" }));
+    },
+    resume() {
+      if (!controls.ready || !paused) return;
+      paused = false; controls.player?.resume();
+      void controls.file?.resume()?.catch?.(() => controls.connection?.close());
+      if (controls.connection?.readyState === 1) controls.connection.send(JSON.stringify({ type: "resume" }));
+    },
   });
-  try {
-    await new Promise((resolve, reject) => {
-      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 }) => {
-        if (typeof data !== "string" && !firstReceived) { firstReceived = true; streamMetric(options, { stage: "playback_first_received", durationMs: Date.now() - started }); }
-        let event = null;
-        if (typeof data === "string") {
-          try { event = JSON.parse(data); } catch (error) { chain = chain.then(() => { throw error; }).catch(fail); return; }
-          if (event?.type === "done") ending = true;
-        }
-        chain = chain.then(async () => {
-          if (options.signal?.aborted) throw new Error("voice_cancelled");
-          if (typeof data !== "string") { player.write(new Uint8Array(data)); return; }
-          if (event.type === "segment") {
-            if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
-            segmentIndex = event.index;
+
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    if (attempt > 0) {
+      if (options.signal?.aborted) throw new Error("voice_cancelled");
+      streamMetric(options, { stage: "playback_reconnect", attempt, skipFrames, code: lastError?.message || "voice_disconnected", ...clientFacts() });
+      await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+      if (options.signal?.aborted) throw new Error("voice_cancelled");
+    }
+    const connection = await openAudioStream({ ...options, operation: "tts" });
+    if (!connection) throw new Error("voice_stream_failed");
+    const file = createBrowserPlayer();
+    let progressNoted = false, progressBlocked = false;
+    let lastProgressAt = Date.now(), gapReported = false, gapAt = 0, formatNoted = false;
+    let chain = Promise.resolve(), complete = false, ending = false, firstReceived = false, ready = false, segmentIndex = -1;
+    // The skipped prefix belongs to this new socket and is acknowledged as it
+    // arrives, so the host keeps sending it without waiting for a playhead
+    // that only starts after the skip.
+    let skipBytes = skipFrames * 2;
+    let skippedFrames = 0;
+    let skipAckAt = 0;
+    const player = createPcmStreamPlayer({
+      onProgress: (frames) => {
+        lastProgressAt = Date.now();
+        if (gapReported) { gapReported = false; streamMetric(options, { stage: "playback_gap_end", frames: skipFrames + frames, gapMs: Date.now() - gapAt, ...clientFacts(), context: player.contextState() }); }
+        ack(skipFrames + frames);
+      },
+      onMetric: (event) => {
+        if (event.stage === "playback_started") options.onStatus?.("playing");
+        streamMetric(options, { ...event, durationMs: Date.now() - started });
+      },
+    });
+    controls.player = player;
+    controls.connection = connection;
+    controls.file = file;
+    controls.ready = false;
+    const ack = (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 }); }
+    };
+    const writeAudio = (bytes) => {
+      let chunk = bytes;
+      if (skipBytes > 0) {
+        const drop = Math.min(skipBytes, chunk.length);
+        skipBytes -= drop;
+        skippedFrames += drop / 2;
+        if (Date.now() - skipAckAt >= 40) { skipAckAt = Date.now(); ack(skippedFrames); }
+        chunk = chunk.subarray(drop);
+        if (!chunk.length) return;
+      }
+      player.write(chunk);
+    };
+    const gapWatch = setInterval(() => {
+      if (!ready || paused || complete || gapReported || Date.now() - lastProgressAt < 4000) return;
+      gapReported = true;
+      gapAt = lastProgressAt;
+      streamMetric(options, { stage: "playback_gap", gapMs: Date.now() - lastProgressAt, frames: skipFrames + player.playedFrames(), ...clientFacts(), context: player.contextState(), sampleRate: player.sampleRate() });
+    }, 1000);
+    gapWatch.unref?.();
+    const noteVisibility = () => {
+      if (ready && !complete) streamMetric(options, { stage: "playback_visibility", frames: skipFrames + player.playedFrames(), paused, ...clientFacts(), context: player.contextState() });
+    };
+    if (typeof document !== "undefined" && document.addEventListener) document.addEventListener("visibilitychange", noteVisibility);
+    try {
+      await new Promise((resolve, reject) => {
+        let logged = false;
+        const fail = (error) => {
+          if (logged) return;
+          logged = true;
+          reject(error);
+        };
+        const cancelled = () => { player.stop(); file.stop(); fail(new Error("voice_cancelled")); };
+        options.signal?.addEventListener("abort", cancelled, { once: true });
+        connection.addEventListener("message", ({ data }) => {
+          if (typeof data !== "string" && !firstReceived) { firstReceived = true; streamMetric(options, { stage: "playback_first_received", durationMs: Date.now() - started }); }
+          let event = null;
+          if (typeof data === "string") {
+            try { event = JSON.parse(data); } catch (error) { chain = chain.then(() => { throw error; }).catch(fail); return; }
+            if (event?.type === "done") ending = true;
           }
-          else if (event.type === "segment.end") options.onSegment?.(event);
-          else if (event.type === "format") { await player.start(event); ready = true; if (paused) player.pause(); }
-          else if (event.type === "file") { ready = true; options.onStatus?.("playing"); await file.play(wavBlob(event.audio)); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "file.done" })); }
-          else if (event.type === "error") throw new Error(event.code || "voice_stream_failed");
-          else if (event.type === "done") { await player.finish(); complete = true; resolve(); }
-        }).catch(fail);
+          chain = chain.then(async () => {
+            if (options.signal?.aborted) throw new Error("voice_cancelled");
+            if (typeof data !== "string") { writeAudio(new Uint8Array(data)); return; }
+            if (event.type === "segment") {
+              if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
+              segmentIndex = event.index;
+            }
+            else if (event.type === "segment.end") options.onSegment?.(event);
+            else if (event.type === "format") {
+              await player.start(event); ready = controls.ready = true; lastProgressAt = Date.now();
+              if (paused) {
+                player.pause();
+                if (connection.readyState === 1) connection.send(JSON.stringify({ type: "pause" }));
+              }
+              if (!formatNoted) { formatNoted = true; streamMetric(options, { stage: "playback_client", sampleRate: event.sampleRate, context: player.contextState(), ...clientFacts() }); }
+            }
+            else if (event.type === "file") {
+              // A whole-file answer cannot be offset-skipped; a reconnect plays it again.
+              ready = controls.ready = true; options.onStatus?.("playing");
+              await file.play(wavBlob(event.audio));
+              if (connection.readyState === 1) connection.send(JSON.stringify({ type: "file.done" }));
+            }
+            else if (event.type === "error") throw new Error(event.code || "voice_stream_failed");
+            else if (event.type === "done") { await player.finish(); complete = true; resolve(); }
+          }).catch(fail);
+        });
+        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 && !ending) fail(dropped());
+        }, { once: true });
+        if (options.signal?.aborted) cancelled();
       });
-      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 && !ending) { const error = dropped(); noteFailure(error); reject(error); }
-      }, { once: true });
-      if (options.signal?.aborted) cancelled();
-    });
-    return true;
-  } finally { player.stop(); file.stop(); connection.close(); }
+      return true;
+    } catch (error) {
+      lastError = error;
+      if (reconnectable(error) && attempt < attempts - 1) {
+        skipFrames += player.playedFrames();
+        continue;
+      }
+      if (error?.message !== "voice_cancelled") {
+        streamMetric(options, { stage: "playback_failed", code: error?.message || "voice_playback_failed", durationMs: Date.now() - started });
+      }
+      throw error;
+    } finally {
+      clearInterval(gapWatch);
+      if (typeof document !== "undefined" && document.removeEventListener) document.removeEventListener("visibilitychange", noteVisibility);
+      if (controls.player === player) { controls.player = null; controls.connection = null; controls.file = null; controls.ready = false; }
+      player.stop(); file.stop(); connection.close();
+    }
+  }
+  throw lastError || new Error("voice_disconnected");
 }
 
 /** A single final ASR result; partials never submit a task or replace the draft. */

package/voice/stream-gateway.js

@@ -10,7 +10,7 @@ import { routerGatewayUrl, routerAuthHeaders } from "../router/gateway.js";
 const fault = (code, status = 409) => new VoiceError(code, status, code);
 
 /** Single-use HTTP grants bind raw audio sockets to the authenticated Host scope. */
-export function createAudioStreamGateway({ config, models, replies, synthesize = synthesizeStream, env = process.env, metric = () => {}, playbackStallMs = 45_000 }) {
+export function createAudioStreamGateway({ config, models, replies, synthesize = synthesizeStream, env = process.env, metric = () => {}, playbackStallMs = 45_000, pauseHoldMs = 120_000, lifetimeMs = 300_000 }) {
   const tickets = new Map(), clients = new Set();
   const synthesis = createSynthesisRuns({ synthesize, metric });
   const server = new WebSocketServer({ noServer: true, maxPayload: 96 * 1024, perMessageDeflate: false,
@@ -66,7 +66,7 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
           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);
+        const lifetime = setTimeout(() => error(fault("voice_timeout")), lifetimeMs);
         client.on("close", close); client.on("error", close);
         client.on("message", (raw, binary) => {
           try {
@@ -149,7 +149,10 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
                     // while without the client being gone. Wait for it to come
                     // back instead of ending the answer after ten seconds.
                     await new Promise((resolve, reject) => {
-                      const limit = pausedAt ? Math.max(1, 10_000 - (Date.now() - pausedAt)) : playbackStallMs;
+                      // A locked screen or a device switch is a pause, not a
+                      // lost client: hold the answer long enough for the page
+                      // to come back before failing it.
+                      const limit = pausedAt ? Math.max(1, pauseHoldMs - (Date.now() - pausedAt)) : playbackStallMs;
                       const timer = setTimeout(() => { waiter = null; reject(fault(pausedAt ? "voice_interruption_timeout" : "voice_audio_backpressure")); }, limit);
                       waiter = () => { clearTimeout(timer); resolve(); };
                     });

package/voice/tts-settings.js

@@ -12,7 +12,10 @@ export function ttsSettingsModel(value) {
 /** Framework-neutral settings lifecycle; model switches invalidate both audio and directory results. */
 export function createTtsSettings({ preferences, list = fetchTtsVoices, preview, activity = voiceActivity }) {
   const initialModel = ttsSettingsModel(preferences.getSnapshot().value);
-  let state = { model: initialModel, voices: [], selected: ttsVoiceForModel(preferences.getSnapshot().value?.config || {}, initialModel) || "", loading: Boolean(initialModel), error: null, saving: false, playing: false, previewError: null, blocked: activity.getSnapshot(), unavailable: false };
+  let state = { model: initialModel, voices: [], selected: ttsVoiceForModel(preferences.getSnapshot().value?.config || {}, initialModel) || "", loading: Boolean(initialModel), error: null, stale: false, saving: false, playing: false, previewError: null, blocked: activity.getSnapshot(), unavailable: false };
+  // A transient failure keeps the last directory this page loaded for the model
+  // instead of turning a working voice picker into an error screen.
+  const cached = new Map();
   const listeners = new Set();
   let generation = 0, listing = null, playing = null, disposed = false;
   const emit = patch => { if (disposed) return; state = { ...state, ...patch }; for (const listener of listeners) listener(); };
@@ -25,16 +28,20 @@ export function createTtsSettings({ preferences, list = fetchTtsVoices, preview,
   const load = async () => {
     const token = ++generation; listing?.abort(); stop();
     const model = ttsSettingsModel(preferences.getSnapshot().value);
-    emit({ model, voices: [], loading: Boolean(model), error: null, unavailable: false, previewError: null });
+    emit({ model, voices: [], loading: Boolean(model), error: null, stale: false, unavailable: false, previewError: null });
     updateSelection();
     if (!model) return;
     const abort = listing = new AbortController();
     try {
-      const voices = await list(model, { signal: AbortSignal.any([abort.signal, AbortSignal.timeout(10000)]) });
+      const voices = await list(model, { signal: AbortSignal.any([abort.signal, AbortSignal.timeout(30_000)]) });
       if (token !== generation || disposed) return;
-      emit({ voices, loading: false }); updateSelection();
+      cached.set(model, voices);
+      emit({ voices, loading: false, error: null, stale: false }); updateSelection();
     } catch (error) {
-      if (token === generation && !disposed && !abort.signal.aborted) emit({ loading: false, error: "tts_voices_failed" });
+      if (token !== generation || disposed || abort.signal.aborted) return;
+      const previous = cached.get(model);
+      if (previous) { emit({ voices: previous, loading: false, error: null, stale: true }); updateSelection(); }
+      else emit({ loading: false, error: "tts_voices_failed", stale: false });
     }
   };
   let wasLoading = preferences.getSnapshot().loading, catalog = JSON.stringify(preferences.getSnapshot().value?.ttsModels || []);

package/voice/tts-voice.js

@@ -4,17 +4,58 @@ export function ttsVoiceForModel(config, model) {
   return config.ttsModel === model ? config.voice || undefined : undefined;
 }
 
-export async function fetchTtsVoices(model, { signal, fetcher = fetch } = {}) {
-  const res = await fetcher(`/llm/v1/audio/voices?model=${encodeURIComponent(model)}`, { signal: signal ?? AbortSignal.timeout(10000) });
-  const body = await res.json().catch(() => null);
-  if ((res.status === 404 && /no preset voices/i.test(String(body?.detail || body?.error?.message || ""))) || res.status === 405 || res.status === 501) return [];
-  if (!res.ok) throw new Error("tts_voices_failed");
-  if (!Array.isArray(body?.voices)) throw new Error("tts_voices_failed");
-  const seen = new Set();
-  return body.voices.flatMap(row => {
-    const id = typeof row === "string" ? row : row?.id;
-    if (typeof id !== "string" || !id || seen.has(id)) return [];
-    seen.add(id);
-    return [{ id, label: typeof row?.name === "string" && row.name.trim() ? row.name : id }];
+// A cold or busy TTS engine answers 5xx until its model is ready. The directory
+// is metadata, so a couple of short retries are enough and keep the settings
+// usable instead of failing on the first probe.
+const ATTEMPT_TIMEOUT_MS = 8_000;
+const RETRY_DELAYS_MS = [500, 1_500];
+const TRANSIENT_STATUS = new Set([429, 500, 502, 503, 504]);
+
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { cleanup(); resolve(); }, ms);
+    const stop = () => { cleanup(); reject(new Error("voice_voices_aborted")); };
+    const cleanup = () => { clearTimeout(timer); signal?.removeEventListener("abort", stop); };
+    signal?.addEventListener("abort", stop, { once: true });
+    if (signal?.aborted) stop();
   });
 }
+
+function attemptSignal(signal) {
+  const timeout = typeof AbortSignal?.timeout === "function" ? AbortSignal.timeout(ATTEMPT_TIMEOUT_MS) : null;
+  if (signal && timeout && typeof AbortSignal.any === "function") {
+    try { return AbortSignal.any([signal, timeout]); } catch { /* caller signal only */ }
+  }
+  return signal ?? timeout ?? undefined;
+}
+
+export async function fetchTtsVoices(model, { signal, fetcher = fetch, retryDelays = RETRY_DELAYS_MS } = {}) {
+  const url = `/llm/v1/audio/voices?model=${encodeURIComponent(model)}`;
+  const failure = new Error("tts_voices_failed");
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const res = await fetcher(url, { signal: attemptSignal(signal) });
+      const body = await res.json().catch(() => null);
+      if ((res.status === 404 && /no preset voices/i.test(String(body?.detail || body?.error?.message || ""))) || res.status === 405 || res.status === 501) return [];
+      if (!res.ok) {
+        if (TRANSIENT_STATUS.has(res.status) && attempt < retryDelays.length && !signal?.aborted) {
+          await delay(retryDelays[attempt], signal);
+          continue;
+        }
+        throw failure;
+      }
+      if (!Array.isArray(body?.voices)) throw failure;
+      const seen = new Set();
+      return body.voices.flatMap(row => {
+        const id = typeof row === "string" ? row : row?.id;
+        if (typeof id !== "string" || !id || seen.has(id)) return [];
+        seen.add(id);
+        return [{ id, label: typeof row?.name === "string" && row.name.trim() ? row.name : id }];
+      });
+    } catch (error) {
+      if (error === failure) throw failure;
+      if (signal?.aborted || attempt >= retryDelays.length) throw failure;
+      await delay(retryDelays[attempt], signal);
+    }
+  }
+}

package/voice/unified-conversation.js

@@ -274,7 +274,9 @@ export function createUnifiedConversation({ request, socket: openSocket = browse
     lastSessionId = state.sessionId;
     if (lastSessionId) controller.bindSession(lastSessionId);
     if (state.error && state.error !== "voice_cancelled") throw new Error(state.error);
-    controller.observeAgent(Boolean(state.running) || Boolean(reply), Boolean(reply?.audio));
+    // A finished reply is not a running agent: keeping it "running" left the
+    // panel on Working forever and blocked the next continuous turn.
+    controller.observeAgent(Boolean(state.running), Boolean(reply?.audio));
   };
   const watch = async () => {
     if (disposed || controller.getSnapshot().connection === "closed") return;

package/voice/wake-lock.js

@@ -0,0 +1,52 @@
+/**
+ * A phone that turns its screen off suspends the WebView: the AudioContext is
+ * interrupted and the socket is torn down, so a long answer stops after the
+ * first sentences. Keeping the screen awake for the length of a readout is the
+ * only part of that chain the page itself can control.
+ *
+ * The lock is only a hint. A WebView without `navigator.wakeLock`, or a request
+ * the platform refuses (no gesture, low power mode), must leave playback alone.
+ */
+export function createScreenWakeLock(nav = globalThis.navigator, doc = globalThis.document) {
+  let sentinel = null;
+  let wanted = false;
+  let watching = false;
+  const supported = () => typeof nav?.wakeLock?.request === "function";
+
+  const drop = () => {
+    const held = sentinel;
+    sentinel = null;
+    if (!held) return;
+    try { void held.release?.()?.catch?.(() => {}); } catch { /* already released */ }
+  };
+
+  const acquire = async () => {
+    if (!wanted || sentinel || !supported() || doc?.visibilityState === "hidden") return false;
+    try {
+      const held = await nav.wakeLock.request("screen");
+      // The answer may have ended while the platform was answering the request.
+      if (!wanted) { try { void held.release?.()?.catch?.(() => {}); } catch { /* already released */ } return false; }
+      sentinel = held;
+      held.addEventListener?.("release", () => { if (sentinel === held) sentinel = null; });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  // A hidden page loses its lock. Re-acquire through the platform's own rule
+  // instead of guessing when the page is allowed to hold one again.
+  const watch = () => {
+    if (watching || !doc?.addEventListener) return;
+    watching = true;
+    doc.addEventListener("visibilitychange", () => { if (wanted && doc.visibilityState === "visible") void acquire(); });
+  };
+
+  return {
+    get supported() { return supported(); },
+    get held() { return Boolean(sentinel); },
+    /** Ask for the lock; resolves to whether the platform granted it. */
+    async hold() { wanted = true; watch(); return acquire(); },
+    release() { wanted = false; drop(); },
+  };
+}