dsh-live-voice 0.3.2 → 0.4.1

package/src/modules/core/coordinator.ts

@@ -5,8 +5,10 @@ import {
   filterSpeechOutput,
   hasMinimumWords,
   hasUnclosedCodeFence,
+  hasIncompleteSpeechMarkdown,
   matchVoiceCommand,
   splitSpeechOutput,
+  splitInitialSpeechItem,
 } from './filters.ts';
 
 const message = (error) => error?.message || String(error);
@@ -26,14 +28,16 @@ function cancellable(promise, signal) {
 
 /** Session-owned policy. Input transitions are serialized; generations invalidate late work. */
 export class VoiceCoordinator {
-  constructor({ recognition, engines, meter, composer, settings = {} }) {
-    Object.assign(this, { recognition, engines, meter, composer });
+  constructor({ recognition, engines, meter, composer, settings = {}, persistSettings }) {
+    Object.assign(this, { recognition, engines, meter, composer, persistSettings });
     this.listeners = new Set();
     this.transcript = new TranscriptDraft();
     this.epoch = 0;
     this.speechEpoch = 0;
     this.controlEpoch = 0;
     this.queue = [];
+    this.speechHistory = [];
+    this.speechCursor = -1;
     this.prefetchController = new AbortController();
     this.prefetchItems = new Set();
     this.activeSpeechItem = null;
@@ -56,9 +60,16 @@ export class VoiceCoordinator {
       starting: false,
       error: null,
       activeMessageId: null,
+      speechLoading: false,
+      speechText: null,
+      speechEngine: null,
       answeringQuestion: false,
       autoSendAt: null,
       speechSegmentsRemaining: 0,
+      speechSegmentIndex: 0,
+      speechSegmentsTotal: 0,
+      speechHasPrevious: false,
+      speechRunActive: false,
       capabilities: {},
       settings: normalizeSettings(settings),
     };
@@ -66,6 +77,7 @@ export class VoiceCoordinator {
     this.autoSendDraft = null;
     this.holdToTalkRelease = false;
     this.interruptionTimer = null;
+    this.interruptionResumeTimer = null;
     this.interruptionTranscriptConfirmed = false;
     this.interruptionPausedSpeech = false;
     this.assistantSpeechTimer = null;
@@ -131,7 +143,7 @@ export class VoiceCoordinator {
     this.patch({
       settings,
       muted: settings.microphoneEnabled === false,
-      recognizing: settings.microphoneEnabled === false ? false : this.snapshot.recognizing,
+      recognizing: this.snapshot.recognizing,
       error: null,
     });
     if (settings.sendingMode === 'manual') this.cancelAutoSend();
@@ -223,12 +235,15 @@ export class VoiceCoordinator {
   startConversation() {
     return this.startListening(true);
   }
+  toggleTimestamps() {
+    this.patch({ timestamps: !this.snapshot.timestamps });
+  }
   muteListening() {
     this.cancelAutoSend();
     // Discard pending recognition without rewriting the composer.
     this.transcript.reset();
     this.updateSettings({ microphoneEnabled: false });
-    if (!this.snapshot.settings.voiceCommandsEnabled) return this.stopListening();
+    // Ignoring discards text; capture and interruption remain active even without voice commands.
   }
   resumeListeningInput() {
     this.transcript.reset();
@@ -273,7 +288,32 @@ export class VoiceCoordinator {
           throw new Error(capability.reason || 'Local browser recognition is unavailable.');
         let started;
         try {
-          started = await this.meter.start({ signal: controller.signal });
+          const deviceId = this.snapshot.settings.inputDeviceId;
+          try {
+            started = await this.meter.start({ signal: controller.signal });
+          } catch (error) {
+            if (
+              error?.name !== 'OverconstrainedError' ||
+              !deviceId ||
+              !valid() ||
+              controller.signal.aborted ||
+              this.snapshot.settings.inputDeviceId !== deviceId
+            )
+              throw error;
+            // Repair only the obsolete input preference, without ending this input operation.
+            VoiceCoordinator.prototype.updateSettings.call(this, { inputDeviceId: '' });
+            await cancellable(
+              Promise.resolve(this.persistSettings?.({ inputDeviceId: '' })),
+              controller.signal,
+            );
+            if (
+              !valid() ||
+              controller.signal.aborted ||
+              this.snapshot.settings.inputDeviceId !== ''
+            )
+              return;
+            started = await this.meter.start({ signal: controller.signal });
+          }
         } catch (error) {
           if (valid())
             this.patch({
@@ -307,22 +347,22 @@ export class VoiceCoordinator {
             if (!valid()) return;
             const count = Number.isSafeInteger(pending) && pending >= 0 ? pending : 0;
             this.patch({ pendingTranscriptions: count });
-            if (count > 0) this.cancelAutoSend();
+            if (count > 0) this.cancelAutoSend({ preserveIntent: true });
             else if (this.holdToTalkRelease) this._finishHoldToTalk();
             else this.maybeScheduleAutoSend();
           },
           onActivity: (active) => {
             if (!valid()) return;
             if (active) {
-              this.cancelAutoSend();
+              this.cancelAutoSend({ preserveIntent: true });
               this.assistantSpeechNotBefore = Infinity;
               this._cancelAssistantSpeechTimer();
             } else
               this.assistantSpeechNotBefore =
                 Date.now() + this.snapshot.settings.assistantSpeechDelaySeconds * 1000;
             this.patch({ recognizing: active });
-            this._handleSpeechInterruption(active);
-            if (!active) this._drain();
+            this._handleSpeechInterruption(this._speechActivity());
+            if (!active) { this.refreshDeliveryReadiness(); this._drain(); }
           },
           onError: (error) => {
             if (!valid()) return;
@@ -361,11 +401,51 @@ export class VoiceCoordinator {
     return hasMinimumWords(text, 1);
   }
 
+  _speechActivity() {
+    return this.snapshot.recognizing || this.externalSpeechActive;
+  }
+  setExternalSpeechActivity(active) {
+    if (this.disposed) return;
+    this.externalSpeechActive = Boolean(active);
+    if (!active) this.externalSpeechConfirmed = false;
+    if (active) {
+      this.assistantSpeechNotBefore = Infinity;
+      this._cancelAssistantSpeechTimer();
+    } else if (!this.snapshot.recognizing) {
+      this.assistantSpeechNotBefore =
+        Date.now() + this.snapshot.settings.assistantSpeechDelaySeconds * 1000;
+    }
+    this._handleSpeechInterruption(this._speechActivity());
+    if (!active) this._drain();
+  }
+  confirmExternalSpeech(text) {
+    if (this.disposed) return false;
+    const normalized = (value) =>
+      String(value || '')
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim();
+    const heard = normalized(text);
+    const own = normalized(this.snapshot.speechText);
+    // System-audio mixes may still contain TTS despite browser exclusion hints.
+    if (this.snapshot.speaking && heard && own.includes(heard)) return false;
+    if (this.externalSpeechActive && this._interruptionTranscriptQualifies(text)) {
+      this.externalSpeechConfirmed = true;
+      this._handleSpeechInterruption(true);
+    }
+    return true;
+  }
   _handleSpeechInterruption(active) {
-    if (this.snapshot.settings.mode !== 'headphones') return;
+    if (
+      this.snapshot.settings.mode !== 'headphones' &&
+      !this.externalSpeechConfirmed &&
+      !this.interruptionPausedSpeech
+    )
+      return;
     if (active) {
+      this._cancelInterruptionResume();
       if (
-        !this.interruptionTranscriptConfirmed ||
+        !(this.interruptionTranscriptConfirmed || this.externalSpeechConfirmed) ||
         this.interruptionTimer !== null ||
         !this.snapshot.speaking ||
         this.snapshot.paused
@@ -374,21 +454,14 @@ export class VoiceCoordinator {
       this.interruptionTimer = setTimeout(() => {
         this.interruptionTimer = null;
         if (
-          this.interruptionTranscriptConfirmed &&
-          this.snapshot.recognizing &&
+          (this.interruptionTranscriptConfirmed || this.externalSpeechConfirmed) &&
+          this._speechActivity() &&
           this.snapshot.speaking &&
           !this.snapshot.paused
         ) {
           this.interruptionPausedSpeech = true;
-          void this.pauseSpeech().then(() => {
-            if (
-              this.interruptionPausedSpeech &&
-              !this.snapshot.recognizing &&
-              this.snapshot.paused
-            ) {
-              this.interruptionPausedSpeech = false;
-              void this.resumeSpeech();
-            }
+          void this.pauseSpeech(true).then(() => {
+            if (!this._speechActivity()) this._scheduleInterruptionResume();
           });
         }
       }, this.snapshot.settings.assistantSpeechDelaySeconds * 1000);
@@ -397,13 +470,38 @@ export class VoiceCoordinator {
     if (this.interruptionTimer !== null) clearTimeout(this.interruptionTimer);
     this.interruptionTimer = null;
     this.interruptionTranscriptConfirmed = false;
-    if (this.interruptionPausedSpeech && this.snapshot.paused) {
+    this._scheduleInterruptionResume();
+  }
+  _cancelInterruptionResume() {
+    if (this.interruptionResumeTimer !== null) clearTimeout(this.interruptionResumeTimer);
+    this.interruptionResumeTimer = null;
+  }
+  _scheduleInterruptionResume() {
+    if (
+      !this.interruptionPausedSpeech ||
+      !this.snapshot.paused ||
+      this._speechActivity() ||
+      this.interruptionResumeTimer !== null
+    )
+      return;
+    const epoch = this.speechEpoch;
+    const control = this.controlEpoch;
+    this.interruptionResumeTimer = setTimeout(() => {
+      this.interruptionResumeTimer = null;
+      if (
+        this.disposed ||
+        epoch !== this.speechEpoch ||
+        control !== this.controlEpoch ||
+        this._speechActivity() ||
+        !this.interruptionPausedSpeech
+      )
+        return;
       this.interruptionPausedSpeech = false;
       void this.resumeSpeech();
-    }
+    }, this.snapshot.settings.assistantSpeechDelaySeconds * 1000);
   }
 
-  onResult({ final = '', interim = '' }) {
+  onResult({ final = '', interim = '', startedAt }) {
     if (this.disposed || (!this.snapshot.listening && !this.snapshot.starting)) return;
     if (
       this.snapshot.speaking &&
@@ -422,6 +520,7 @@ export class VoiceCoordinator {
     // Pending structured questions own recognition while waiting for a hands-free
     // answer. Keep their interim and final text out of the normal chat composer.
     if (
+      !this.snapshot.muted &&
       typeof this.composer.handleQuestionResult === 'function' &&
       this.composer.handleQuestionResult({ final, interim })
     ) {
@@ -463,7 +562,7 @@ export class VoiceCoordinator {
         } else if (this.snapshot.muted) return;
         else {
           const sendingMode = command === 'send' ? 'steer' : 'queue';
-          this.updateSettings({ sendingMode });
+          // Spoken delivery is a one-shot action, not an automatic-send preference change.
           if (this.composer.getDraft().trim() && typeof this.composer.submit === 'function')
             this.composer.submit(sendingMode);
         }
@@ -472,7 +571,13 @@ export class VoiceCoordinator {
       if (this.snapshot.muted) {
         // Discard pending recognition without rewriting the composer.
         this.transcript.reset();
-        this.patch({ recognizing: false });
+        this.patch({ recognizing: !!interim });
+        this._handleSpeechInterruption(this._speechActivity());
+        if (!interim) {
+          this.assistantSpeechNotBefore =
+            Date.now() + this.snapshot.settings.assistantSpeechDelaySeconds * 1000;
+          this._drain();
+        }
         return;
       }
       if (
@@ -482,45 +587,64 @@ export class VoiceCoordinator {
         // Discard pending recognition without rewriting the composer.
         this.transcript.reset();
         this.patch({ recognizing: false });
+        this.refreshDeliveryReadiness();
         return;
       }
-      const next = this.transcript.update(this.composer.getDraft(), final, true);
-      this.composer.setDraft(next);
+      this.cancelAutoSend();
+      const appended = this.composer.appendFinal?.(final, startedAt);
+      const next = appended ?? this.transcript.update(this.composer.getDraft(), final, true);
+      if (appended == null) this.composer.setDraft(next);
+      if (this.snapshot.settings.sendingMode !== 'manual') this.autoSendIntent = next;
       this.maybeScheduleAutoSend(next);
     }
     if (interim) {
-      this.cancelAutoSend();
+      this.cancelAutoSend({ preserveIntent: true });
       // Interim hypotheses affect recognition status only, never composer content.
     }
     if (!interim && this.snapshot.recognizing)
       this.assistantSpeechNotBefore =
         Date.now() + this.snapshot.settings.assistantSpeechDelaySeconds * 1000;
     this.patch({ recognizing: !!interim });
+    this.refreshDeliveryReadiness();
+    this._handleSpeechInterruption(this._speechActivity());
     this._drain();
   }
-  maybeScheduleAutoSend(draft = this.composer.getDraft()) {
+  maybeScheduleAutoSend(draft = this.autoSendIntent) {
+    if (draft == null || draft !== this.composer.getDraft()) return;
+    if (this.autoSendTimer !== null) return;
     if (
       this.snapshot.settings.sendingMode === 'manual' ||
+      this.snapshot.muted ||
+      this.composer.canAutoSend?.() === false ||
       this.snapshot.recognizing ||
       this.snapshot.pendingTranscriptions > 0
     )
       return;
     this.scheduleAutoSend(draft);
   }
+  refreshDeliveryReadiness() {
+    if (this.composer.canAutoSend?.() === false || this.snapshot.recognizing || this.snapshot.pendingTranscriptions > 0)
+      this.cancelAutoSend({ preserveIntent: true });
+    else this.maybeScheduleAutoSend();
+  }
   scheduleAutoSend(draft, { force = false, stopAfter = false } = {}) {
     this.cancelAutoSend();
     if (!draft.trim() || typeof this.composer.submit !== 'function') return;
     const delay = this.snapshot.settings.autoSendDelaySeconds * 1000;
     this.autoSendDraft = draft;
+    this.autoSendIntent = draft;
     this.patch({ autoSendAt: Date.now() + delay });
     this.autoSendTimer = setTimeout(() => {
       this.autoSendTimer = null;
       const expected = this.autoSendDraft;
+      this.autoSendIntent = null;
       this.autoSendDraft = null;
       this.patch({ autoSendAt: null });
       if (
         !this.disposed &&
         (force || this.snapshot.settings.sendingMode !== 'manual') &&
+        !this.snapshot.muted &&
+        this.composer.canAutoSend?.() !== false &&
         expected === this.composer.getDraft()
       ) {
         try {
@@ -542,18 +666,22 @@ export class VoiceCoordinator {
           this._drain();
         }
       } else {
+        if (!this.disposed && !this.snapshot.muted && expected === this.composer.getDraft() &&
+            this.snapshot.settings.sendingMode !== 'manual' && this.composer.canAutoSend?.() === false)
+          this.autoSendIntent = expected;
         this._drain();
       }
     }, delay);
   }
-  cancelAutoSend() {
+  cancelAutoSend({ preserveIntent = false } = {}) {
+    if (!preserveIntent) this.autoSendIntent = null;
     if (this.autoSendTimer !== null) clearTimeout(this.autoSendTimer);
     this.autoSendTimer = null;
     this.autoSendDraft = null;
     if (this.snapshot?.autoSendAt !== null) this.patch({ autoSendAt: null });
   }
   composerChanged(draft) {
-    if (this.autoSendDraft !== null && draft !== this.autoSendDraft) this.cancelAutoSend();
+    if (this.autoSendIntent != null && draft !== this.autoSendIntent) this.cancelAutoSend();
   }
   stopListening() {
     this.holdToTalkRelease = false;
@@ -586,13 +714,27 @@ export class VoiceCoordinator {
     this.prefetchController.abort();
     this.prefetchController = new AbortController();
     for (const item of this.prefetchItems) {
-      item.prepared?.dispose?.();
-      item.prepared = null;
+      if (!this.speechHistory.includes(item)) {
+        item.prepared?.dispose?.();
+        item.prepared = null;
+      }
       item.preparing = null;
     }
     this.prefetchItems.clear();
   }
 
+  _speechPreparationKey() {
+    const { engine, voice, lang, rate, outputDeviceId } = this.snapshot.settings;
+    return JSON.stringify([engine, voice, lang, rate, outputDeviceId]);
+  }
+  _resetStaleSpeechItem(item, key) {
+    if (item.preparationKey === key) return;
+    item.prepared?.dispose?.();
+    item.prepared = null;
+    item.preparing = null;
+    item.prepareError = null;
+    item.preparationKey = key;
+  }
   _prefetchSpeech() {
     const engine = this.engines[this.snapshot.settings.engine];
     if (typeof engine?.prepare !== 'function') return;
@@ -602,31 +744,75 @@ export class VoiceCoordinator {
       lang: this.snapshot.settings.lang,
       outputDeviceId: this.snapshot.settings.outputDeviceId,
     };
+    const key = this._speechPreparationKey();
     for (const item of this.queue.slice(0, 3)) {
+      this._resetStaleSpeechItem(item, key);
       if (item.prepared || item.preparing) continue;
       this.prefetchItems.add(item);
       const signal = this.prefetchController.signal;
       item.preparing = engine
         .prepare(item.text, { ...options, signal })
         .then((prepared) => {
-          item.preparing = null;
-          if (signal.aborted || !this.queue.includes(item)) {
+          if (item.preparationKey === key) item.preparing = null;
+          if (
+            signal.aborted ||
+            item.preparationKey !== key ||
+            (!this.queue.includes(item) && !this.speechHistory.includes(item))
+          ) {
             prepared.dispose?.();
             this.prefetchItems.delete(item);
           } else item.prepared = prepared;
           return prepared;
         })
         .catch((error) => {
-          item.preparing = null;
-          if (!signal.aborted) item.prepareError = error;
+          if (item.preparationKey === key) {
+            item.preparing = null;
+            if (!signal.aborted) item.prepareError = error;
+          }
         });
     }
   }
 
+  _releaseSpeechHistory() {
+    for (const item of this.speechHistory) item.prepared?.dispose?.();
+    this.speechHistory = [];
+    this.speechCursor = -1;
+  }
+  getSpeechHistory() {
+    const groups = [];
+    for (const item of [...this.speechHistory, ...this.queue]) {
+      let group = groups.at(-1);
+      if (!group || group.messageId !== item.id) {
+        group = { messageId: item.id, segments: [] };
+        groups.push(group);
+      }
+      if (!group.segments.includes(item)) group.segments.push(item);
+    }
+    return groups;
+  }
   _syncSpeechSegments() {
     const speechSegmentsRemaining = this.queue.length + (this.snapshot.speaking ? 1 : 0);
-    if (speechSegmentsRemaining !== this.snapshot.speechSegmentsRemaining)
-      this.patch({ speechSegmentsRemaining });
+    const speechHasPrevious = this.speechCursor > 0;
+    const items = [...new Set([...this.speechHistory, ...this.queue])];
+    const speechSegmentsTotal = items.length;
+    const speechSegmentIndex = this.speechCursor >= 0 ? this.speechCursor + 1 : 0;
+    const speechRunActive =
+      speechSegmentsRemaining > 0 ||
+      this.speechHistory.some((item) => !item.manual && this.unfinished.has(item.id));
+    if (
+      speechSegmentsRemaining !== this.snapshot.speechSegmentsRemaining ||
+      speechHasPrevious !== this.snapshot.speechHasPrevious ||
+      speechRunActive !== this.snapshot.speechRunActive ||
+      speechSegmentsTotal !== this.snapshot.speechSegmentsTotal ||
+      speechSegmentIndex !== this.snapshot.speechSegmentIndex
+    )
+      this.patch({
+        speechSegmentsRemaining,
+        speechHasPrevious,
+        speechRunActive,
+        speechSegmentsTotal,
+        speechSegmentIndex,
+      });
   }
 
   _suppressPending() {
@@ -636,15 +822,25 @@ export class VoiceCoordinator {
     this.queue = [];
   }
   async stopSpeech(resumeListening = true) {
+    this._cancelInterruptionResume();
     if (this.interruptionTimer !== null) clearTimeout(this.interruptionTimer);
     this.interruptionTimer = null;
+    this.interruptionResumeTimer = null;
     this.interruptionTranscriptConfirmed = false;
     this.interruptionPausedSpeech = false;
     const epoch = ++this.speechEpoch;
     ++this.controlEpoch;
     this._cancelSpeechPrefetch();
     this._suppressPending();
-    this.patch({ speaking: false, paused: false, activeMessageId: null });
+    this._releaseSpeechHistory();
+    this.patch({
+      speaking: false,
+      paused: false,
+      activeMessageId: null,
+      speechLoading: false,
+      speechText: null,
+      speechEngine: null,
+    });
     this._syncSpeechSegments();
     const stopped = this.speechBarrier.then(async () => {
       const results = await Promise.allSettled(
@@ -671,50 +867,63 @@ export class VoiceCoordinator {
     )
       await this._startInput(true);
   }
+  async previousSpeechSegment() {
+    if (this.speechCursor <= 0 || this.disposed) return;
+    const replay = this.speechHistory.slice(this.speechCursor - 1);
+    this.queue = [...replay, ...this.queue.filter((item) => !replay.includes(item))];
+    await this._navigateSpeech();
+  }
   async skipSpeechSegment() {
-    // Unlike Stop, Next discards only the active segment. Queued and future
-    // streaming segments remain eligible for playback.
-    if (this.disposed || this.queue.length === 0) return;
-    // During the intentional inter-segment gap there is no active audio. In
-    // that case Next discards the imminent segment and immediately drains the
-    // following one, so the persistent button remains useful.
+    if (this.disposed || !this.queue.length) return;
     if (!this.snapshot.speaking && !this.snapshot.paused) {
       const skipped = this.queue.shift();
-      skipped?.prepared?.dispose?.();
-      this.prefetchItems.delete(skipped);
-      this._cancelAssistantSpeechTimer();
-      this.assistantSpeechNotBefore = 0;
-      this._syncSpeechSegments();
-      this._prefetchSpeech();
-      this._drain();
-      return;
+      if (!this.speechHistory.includes(skipped)) this.speechHistory.push(skipped);
+      this.speechCursor = this.speechHistory.indexOf(skipped);
     }
+    await this._navigateSpeech();
+  }
+  async _navigateSpeech() {
+    this._cancelInterruptionResume();
+    this.interruptionPausedSpeech = false;
+    const engine = this.engines[this.snapshot.speechEngine || this.snapshot.settings.engine];
     const epoch = ++this.speechEpoch;
     ++this.controlEpoch;
     this._cancelAssistantSpeechTimer();
     this.assistantSpeechNotBefore = 0;
-    this._cancelSpeechPrefetch();
-    this.patch({ speaking: false, paused: false, activeMessageId: null });
+    this.patch({ speaking: false, paused: false, speechLoading: false });
     this._syncSpeechSegments();
-    const stopped = this.speechBarrier.then(() =>
-      Promise.resolve().then(() => this.engines[this.snapshot.settings.engine]?.stop()),
-    );
+    const stopped = this.speechBarrier.then(() => engine?.stop());
     this.speechBarrier = stopped.catch(() => {});
     try {
       await stopped;
     } catch (error) {
+      this.speechStopError = error;
       if (epoch === this.speechEpoch) this.patch({ error: message(error) });
       return;
     }
     if (epoch !== this.speechEpoch || this.disposed) return;
     this._drain();
   }
-  async pauseSpeech() {
-    if (this.disposed || !this.snapshot.speaking || this.snapshot.paused) return;
+  getSpeechProgress() {
+    return this.engines[this.snapshot.speechEngine]?.getPlaybackProgress?.() ?? null;
+  }
+  async pauseSpeech(automatic = false) {
+    if (!automatic) {
+      this._cancelInterruptionResume();
+      this.interruptionPausedSpeech = false;
+    }
+    if (this.disposed || this.snapshot.paused) return;
+    if (!this.snapshot.speaking && this.snapshot.speechRunActive) {
+      this._cancelAssistantSpeechTimer();
+      this.patch({ paused: true });
+      return;
+    }
+    if (!this.snapshot.speaking) return;
     const epoch = this.speechEpoch;
     const control = ++this.controlEpoch;
     try {
-      const result = await this.engines[this.snapshot.settings.engine].pause();
+      const result =
+        await this.engines[this.snapshot.speechEngine || this.snapshot.settings.engine].pause();
       if (result !== false) this._cancelSpeechPrefetch();
       if (
         epoch === this.speechEpoch &&
@@ -728,7 +937,15 @@ export class VoiceCoordinator {
     }
   }
   async resumeSpeech() {
+    this._cancelInterruptionResume();
+    this.interruptionPausedSpeech = false;
     if (this.disposed || !this.snapshot.paused) return;
+    if (!this.snapshot.speaking) {
+      this.patch({ paused: false });
+      this.assistantSpeechNotBefore = 0;
+      this._drain();
+      return;
+    }
     const epoch = this.speechEpoch;
     const control = ++this.controlEpoch;
     try {
@@ -737,7 +954,8 @@ export class VoiceCoordinator {
         if (this.inputReleaseError) throw this.inputReleaseError;
       }
       if (epoch !== this.speechEpoch || control !== this.controlEpoch) return;
-      const result = await this.engines[this.snapshot.settings.engine].resume();
+      const result =
+        await this.engines[this.snapshot.speechEngine || this.snapshot.settings.engine].resume();
       if (epoch === this.speechEpoch && control === this.controlEpoch && result !== false) {
         this.patch({ paused: false });
         this._prefetchSpeech();
@@ -756,9 +974,13 @@ export class VoiceCoordinator {
       filterCodeBlocks: this.snapshot.settings.outputCodeFilterEnabled,
       codeBlockMaxLines: this.snapshot.settings.outputCodeMaxLines,
       codeBlockNotice: this.snapshot.settings.outputCodeNotice,
+      lang: this.snapshot.settings.lang,
     });
-    const first = segments.shift();
-    if (!first) return;
+    const initial = segments.shift();
+    if (!initial) return;
+    const parts = splitInitialSpeechItem(initial);
+    const first = parts.shift();
+    segments.unshift(...parts);
     this.queue.push(...segments.map((segment) => ({ text: segment, id: messageId, manual: true })));
     this._prefetchSpeech();
     this._syncSpeechSegments();
@@ -772,15 +994,31 @@ export class VoiceCoordinator {
       this._syncSpeechSegments();
       return;
     }
+    const item =
+      this.activeSpeechItem?.text === text
+        ? this.activeSpeechItem
+        : { text, id: messageId, manual };
+    if (!this.speechHistory.includes(item)) this.speechHistory.push(item);
+    this.speechCursor = this.speechHistory.indexOf(item);
     const epoch = ++this.speechEpoch;
     const engine = this.engines[this.snapshot.settings.engine];
+    this._resetStaleSpeechItem(item, this._speechPreparationKey());
+    item.engine = engine;
     if (!engine) {
       this.queue = [];
       this.patch({ error: 'Speech engine unavailable.' });
       return;
     }
     // Reserve playback synchronously so incoming stream chunks cannot overtake gating.
-    this.patch({ speaking: true, paused: false, activeMessageId: messageId, error: null });
+    this.patch({
+      speaking: true,
+      paused: false,
+      activeMessageId: messageId,
+      speechLoading: true,
+      speechText: text,
+      speechEngine: this.snapshot.settings.engine,
+      error: null,
+    });
     this._syncSpeechSegments();
     let failed = false;
     try {
@@ -792,20 +1030,30 @@ export class VoiceCoordinator {
         if (this.inputReleaseError) throw this.inputReleaseError;
       }
       if (epoch !== this.speechEpoch || this.disposed) return;
-      const queued = this.activeSpeechItem;
+      const queued = item;
       if (queued?.preparing) await queued.preparing;
       if (epoch !== this.speechEpoch || this.disposed) return;
       if (queued?.prepareError) throw queued.prepareError;
       const options = {
+        onPlaybackStart: () => {
+          if (epoch === this.speechEpoch && !this.disposed) this.patch({ speechLoading: false });
+        },
         voice: this.snapshot.settings.voice || undefined,
         rate: this.snapshot.settings.rate,
         outputDeviceId: this.snapshot.settings.outputDeviceId,
       };
+      if (!queued.prepared && typeof engine.prepare === 'function') {
+        const prepared = await engine.prepare(text, options);
+        if (epoch !== this.speechEpoch || this.disposed) {
+          prepared.dispose?.();
+          return;
+        }
+        queued.prepared = prepared;
+      }
       if (queued?.prepared && typeof engine.playPrepared === 'function') {
         const prepared = queued.prepared;
-        queued.prepared = null;
         this.prefetchItems.delete(queued);
-        await engine.playPrepared(prepared, options);
+        await engine.playPrepared(prepared, { ...options, retainPrepared: true });
       } else await engine.speak(text, options);
     } catch (error) {
       if (epoch === this.speechEpoch) {
@@ -815,7 +1063,21 @@ export class VoiceCoordinator {
       }
     } finally {
       if (epoch === this.speechEpoch && !this.disposed) {
-        this.patch({ speaking: false, paused: false, activeMessageId: null });
+        this.patch({
+          speaking: false,
+          paused: false,
+          activeMessageId: null,
+          speechLoading: false,
+          speechText: this.queue.length || this.unfinished.has(messageId) ? text : null,
+          speechEngine:
+            this.queue.length || this.unfinished.has(messageId) ? this.snapshot.speechEngine : null,
+        });
+        if (
+          failed ||
+          (!this.queue.length &&
+            !this.speechHistory.some((item) => !item.manual && this.unfinished.has(item.id)))
+        )
+          this._releaseSpeechHistory();
         this._syncSpeechSegments();
         if (!failed && this.queue.length) {
           this.assistantSpeechNotBefore = Date.now() + this.snapshot.settings.segmentGapMs;
@@ -839,7 +1101,8 @@ export class VoiceCoordinator {
       (!this.snapshot.conversation && !this.queue[0]?.manual) ||
       (!this.snapshot.settings.announceAssistantMessages && !this.queue[0]?.manual) ||
       this.snapshot.speaking ||
-      this.snapshot.recognizing ||
+      this.snapshot.paused ||
+      this._speechActivity() ||
       this.snapshot.starting ||
       (!this.queue[0]?.manual &&
         (this.snapshot.pendingTranscriptions > 0 || this.snapshot.autoSendAt !== null)) ||
@@ -862,7 +1125,7 @@ export class VoiceCoordinator {
     this._prefetchSpeech();
     void this.play(next.text, next.id, next.manual === true).finally(() => {
       if (this.activeSpeechItem === next) this.activeSpeechItem = null;
-      next.prepared?.dispose?.();
+      // Audio remains owned by the playback run until completion.
       this.prefetchItems.delete(next);
     });
   }
@@ -871,6 +1134,16 @@ export class VoiceCoordinator {
     if (this.disposed) return;
     if (complete) this.unfinished.delete(id);
     else this.unfinished.add(id);
+    if (
+      complete &&
+      !this.snapshot.speaking &&
+      !this.queue.length &&
+      this.speechHistory.some((item) => item.id === id)
+    ) {
+      this._releaseSpeechHistory();
+      this.patch({ speechText: null, speechEngine: null });
+      this._syncSpeechSegments();
+    }
     if (
       baseline ||
       !this.snapshot.conversation ||
@@ -888,20 +1161,19 @@ export class VoiceCoordinator {
     const remaining = text.slice(offset);
     const boundary = complete ? remaining.length : remaining.lastIndexOf('\n') + 1;
     if (boundary <= 0) return;
-    if (
-      this.snapshot.settings.outputCodeFilterEnabled &&
-      hasUnclosedCodeFence(remaining.slice(0, boundary)) &&
-      !complete
-    )
-      return;
+    if (!complete && hasIncompleteSpeechMarkdown(remaining.slice(0, boundary))) return;
+    if (hasUnclosedCodeFence(remaining.slice(0, boundary)) && !complete) return;
     const chunk = filterSpeechOutput(remaining.slice(0, boundary).trim(), {
       filterCodeBlocks: this.snapshot.settings.outputCodeFilterEnabled,
       codeBlockMaxLines: this.snapshot.settings.outputCodeMaxLines,
       codeBlockNotice: this.snapshot.settings.outputCodeNotice,
+      lang: this.snapshot.settings.lang,
     }).trim();
     this.consumed.set(id, offset + boundary);
     if (chunk) {
-      this.queue.push({ text: chunk, id });
+      const initial = !this.snapshot.speaking && !this.queue.some((item) => item.prepared);
+      const parts = initial ? splitInitialSpeechItem(chunk) : [chunk];
+      this.queue.push(...parts.map((text) => ({ text, id })));
       this._prefetchSpeech();
       this._syncSpeechSegments();
       this._drain();