release: bump version to 0.0.5.9

F5-TTS ist schnell genug dass der Puffer bei kurzen Saetzen eher
schadet als nuetzt — er verzoegert den play()-Start fuer Sekunden die
dann als Wartezeit auffallen.

Aenderungen:
- audio.ts: TTS_PREROLL_MIN_SEC 1.0 → 0 (Einstellbar in Settings)
- PcmStreamPlayerModule.kt: MIN_PREROLL_SECONDS auf 0.0, Fallback-
  Logic respektiert jetzt 0 als gueltigen Wert (vorher hat der
  .let { if (it > 0) it else DEFAULT } 0 zu 3.5s umgebogen).

Bei preroll=0 greift der Leading-Silence von 200ms immer noch, d.h.
AudioTrack-Startup bleibt sauber. play() wird dann beim allerersten
echten PCM-Chunk aufgerufen.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -650,6 +650,33 @@ In der Diagnostic unter Einstellungen → Sprachausgabe:
 > **Tipp:** Fuer beste Ergebnisse: saubere Aufnahme, eine Stimme, kein Hintergrund,
 > 10-30 Sekunden Gesamtlaenge. Mehrere kurze Dateien werden zusammengefuegt.
 
+### Deutsches Fine-Tune (bessere Qualitaet auf Deutsch)
+
+Das Default-Modell `F5TTS_v1_Base` ist primaer auf Englisch + Chinesisch trainiert
+und liefert auf Deutsch merklich schwaechere Voice-Cloning-Qualitaet als XTTS es
+tat. Community-Fine-Tune von [aihpi](https://huggingface.co/aihpi/F5-TTS-German)
+auf dem Emilia-Dataset + Common Voice 19.0 funktioniert deutlich besser.
+
+**Konfiguration ueber Diagnostic → "F5-TTS Modell-Tuning (advanced)":**
+
+| Feld | Wert |
+|------|------|
+| Modell-Architektur | `F5TTS_Base` *(nicht v1_Base! Fine-Tune basiert auf der alten Architektur)* |
+| Custom Checkpoint | `hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors` |
+| Custom Vocab | `hf://aihpi/F5-TTS-German/vocab.txt` |
+| cfg_strength | `2.0` |
+| nfe_step | `32` |
+
+→ "Anwenden" klicken. Die `hf://`-Pfade werden einmalig automatisch runter-
+geladen (~3-5GB, landet im `xtts/hf-cache/`) und bei Container-Restart aus
+dem Cache wiederverwendet.
+
+> **Warnung zur BigVGAN-Variante** (`F5TTS_Base_bigvgan/model_295000.safetensors`):
+> funktioniert AKTUELL NICHT mit dieser Bridge. Die f5-tts Library laedt
+> per Default den Vocos-Vocoder, die BigVGAN-Weights sind damit inkompatibel
+> → Modell produziert NaN, App bleibt stumm. Nur die **Vocos-Variante
+> (F5TTS_Base/model_365000.safetensors)** nutzen.
+
 ---
 
 ## Docker Volumes

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 505
-        versionName "0.0.5.5"
+        versionCode 509
+        versionName "0.0.5.9"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

android/android/app/src/main/java/com/ariacockpit/PcmStreamPlayerModule.kt

@@ -32,7 +32,10 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
         private const val TAG = "PcmStreamPlayer"
         // Fallback wenn JS keinen Wert uebergibt.
         private const val DEFAULT_PREROLL_SECONDS = 3.5
-        private const val MIN_PREROLL_SECONDS = 0.5
+        // 0.0 = sofortige Wiedergabe — play() direkt beim ersten Chunk.
+        // Macht Sinn fuer F5-TTS weil Render so schnell ist dass ein Puffer
+        // unnoetig ist und bei kurzen Saetzen sogar stoeren kann.
+        private const val MIN_PREROLL_SECONDS = 0.0
         private const val MAX_PREROLL_SECONDS = 10.0
         // Stille am Stream-Anfang, damit AudioTrack sauber anfaehrt und die
         // ersten Samples nicht abgeschnitten werden (XTTS-Warmup + play()-Latenz).
@@ -59,9 +62,12 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
             // Alte Session beenden falls vorhanden
             stopInternal()
 
-            val prerollSec = prerollSeconds
-                .coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
-                .let { if (it.isFinite() && it > 0) it else DEFAULT_PREROLL_SECONDS }
+            // Nur NaN/Inf → Default. 0.0 ist gueltig (= sofortige Wiedergabe).
+            val prerollSec = if (prerollSeconds.isFinite() && prerollSeconds >= 0.0) {
+                prerollSeconds.coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
+            } else {
+                DEFAULT_PREROLL_SECONDS
+            }
 
             val channelConfig = if (channels == 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
             val encoding = AudioFormat.ENCODING_PCM_16BIT
@@ -119,8 +125,13 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                             if (endRequested) {
                                 // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
                                 if (!playbackStarted) {
-                                    try { t.play() } catch (_: Exception) {}
-                                    playbackStarted = true
+                                    try {
+                                        t.play()
+                                        playbackStarted = true
+                                        Log.i(TAG, "Playback gestartet VOR Pre-Roll (kurzer Text, ${bytesBuffered}B gepuffert)")
+                                    } catch (e: Exception) {
+                                        Log.w(TAG, "play() fallback failed: ${e.message}")
+                                    }
                                 }
                                 return@Thread
                             }

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.0.5.5",
+  "version": "0.0.5.9",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/components/MessageText.tsx

@@ -0,0 +1,90 @@
+/**
+ * MessageText — rendert Chat-Text mit Auto-Linkifizierung:
+ *   - http(s)://... → tippbar, oeffnet im Browser
+ *   - mailto: oder plain E-Mail → tippbar, oeffnet Mail-App
+ *   - Telefonnummern → tippbar, oeffnet Android-Dialer
+ *
+ * Text ist durchgaengig markierbar/kopierbar (selectable).
+ */
+
+import React from 'react';
+import { Text, Linking, TextStyle, StyleProp } from 'react-native';
+
+// Regex kombiniert URL | Email | Telefonnummer.
+// Gruppenreihenfolge ist wichtig fuer die Erkennung unten.
+//
+// URL: http://... oder https://... bis zum ersten Whitespace / Anfuehrungszeichen.
+// Email: simpler Standard-Match (kein RFC-kompatibel aber gut genug).
+// Telefon: internationale Form (+49..., 0049..., 0176...), darf Leerzeichen
+//         / Bindestriche / Schraegstriche / Klammern enthalten, mindestens 7
+//         Ziffern insgesamt. Vermeidet banale Zahlen (Uhrzeiten, Datum).
+const LINK_REGEX = new RegExp(
+  '(https?:\\/\\/[^\\s<>"]+)' +                                // 1: URL
+  '|([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,})' +        // 2: Email
+  '|((?:\\+|00)\\d[\\d\\s()\\-\\/]{6,}\\d|0\\d{2,4}[\\s\\/\\-]?[\\d\\s\\-\\/]{5,}\\d)', // 3: Telefon
+  'g',
+);
+
+const LINK_STYLE = { color: '#0096FF', textDecorationLine: 'underline' } as TextStyle;
+
+interface Segment {
+  text: string;
+  kind: 'text' | 'url' | 'email' | 'phone';
+}
+
+function tokenize(raw: string): Segment[] {
+  const out: Segment[] = [];
+  let lastEnd = 0;
+  LINK_REGEX.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = LINK_REGEX.exec(raw)) !== null) {
+    if (m.index > lastEnd) {
+      out.push({ text: raw.slice(lastEnd, m.index), kind: 'text' });
+    }
+    if (m[1]) out.push({ text: m[1], kind: 'url' });
+    else if (m[2]) out.push({ text: m[2], kind: 'email' });
+    else if (m[3]) out.push({ text: m[3], kind: 'phone' });
+    lastEnd = LINK_REGEX.lastIndex;
+  }
+  if (lastEnd < raw.length) out.push({ text: raw.slice(lastEnd), kind: 'text' });
+  return out;
+}
+
+function onPress(seg: Segment) {
+  try {
+    if (seg.kind === 'url') {
+      Linking.openURL(seg.text);
+    } else if (seg.kind === 'email') {
+      Linking.openURL(`mailto:${seg.text}`);
+    } else if (seg.kind === 'phone') {
+      // Android-Dialer erwartet tel:-Schema ohne Leerzeichen/Bindestriche
+      const clean = seg.text.replace(/[\s\-\/()]/g, '');
+      Linking.openURL(`tel:${clean}`);
+    }
+  } catch {}
+}
+
+interface Props {
+  text: string;
+  style?: StyleProp<TextStyle>;
+}
+
+const MessageText: React.FC<Props> = ({ text, style }) => {
+  const segments = React.useMemo(() => tokenize(text), [text]);
+  return (
+    <Text style={style} selectable>
+      {segments.map((seg, i) => {
+        if (seg.kind === 'text') {
+          return <Text key={i}>{seg.text}</Text>;
+        }
+        return (
+          <Text key={i} style={LINK_STYLE} onPress={() => onPress(seg)}>
+            {seg.text}
+          </Text>
+        );
+      })}
+    </Text>
+  );
+};
+
+export default MessageText;

android/src/components/VoiceButton.tsx

@@ -93,18 +93,24 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     }
   }, [isRecording]);
 
-  // VAD Silence Callback — Auto-Stop
+  // VAD Silence Callback — Auto-Stop.
+  // WICHTIG: NICHT auf isRecording prüfen (Closure ist stale) — stattdessen
+  // audioService selber fragen. Empty deps → Listener wird EINMAL registriert.
+  // audioService garantiert jetzt dass der Callback pro Aufnahme nur einmal
+  // feuert (silenceFired-Latch).
+  const onCompleteRef = useRef(onRecordingComplete);
+  useEffect(() => { onCompleteRef.current = onRecordingComplete; }, [onRecordingComplete]);
   useEffect(() => {
     const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (!isRecording) return;
-      setIsRecording(false);
+      if (audioService.getRecordingState() !== 'recording') return;
       const result = await audioService.stopRecording();
+      setIsRecording(false);
       if (result && result.durationMs > 500) {
-        onRecordingComplete(result);
+        onCompleteRef.current(result);
       }
     });
     return unsubSilence;
-  }, [isRecording, onRecordingComplete]);
+  }, []);
 
   // Auto-Start fuer Wake Word (extern getriggert)
   const startAutoRecording = useCallback(async () => {
@@ -136,23 +142,35 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     }
   };
 
-  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop
+  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop.
+  // Guard gegen Doppel-Tap während asyncer Start/Stop.
+  const tapBusy = useRef(false);
   const handleTap = async () => {
-    if (disabled) return;
-    if (isRecording) {
-      // Aufnahme manuell stoppen
-      setIsRecording(false);
-      const result = await audioService.stopRecording();
-      if (result && result.durationMs > 300) {
-        onRecordingComplete(result);
-      }
-    } else {
-      // Aufnahme mit Auto-Stop starten
-      const started = await audioService.startRecording(true);
-      if (started) {
-        isLongPress.current = false;
-        setIsRecording(true);
+    if (disabled || tapBusy.current) return;
+    tapBusy.current = true;
+    try {
+      // Fragen WIR den Service, nicht den React-State (Closure kann stale sein)
+      const svcState = audioService.getRecordingState();
+      if (svcState === 'recording') {
+        // Aufnahme manuell stoppen
+        const result = await audioService.stopRecording();
+        setIsRecording(false);
+        if (result && result.durationMs > 300) {
+          onRecordingComplete(result);
+        }
+      } else if (svcState === 'idle') {
+        // Aufnahme mit Auto-Stop starten
+        const started = await audioService.startRecording(true);
+        if (started) {
+          isLongPress.current = false;
+          setIsRecording(true);
+        }
       }
+      // svcState === 'processing': Stopp in progress — nichts tun, User
+      // muss nochmal tippen wenn fertig. Aber wir blockieren mit tapBusy
+      // kurz damit der User's UI-Feedback synchron bleibt.
+    } finally {
+      tapBusy.current = false;
     }
   };
 

android/src/screens/ChatScreen.tsx

@@ -29,7 +29,8 @@ import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
 import CameraUpload, { PhotoData } from '../components/CameraUpload';
-import { RecordingResult, loadConvWindowMs } from '../services/audio';
+import MessageText from '../components/MessageText';
+import { RecordingResult, loadConvWindowMs, loadTtsSpeed, TTS_SPEED_DEFAULT } from '../services/audio';
 import Geolocation from '@react-native-community/geolocation';
 
 // --- Typen ---
@@ -108,11 +109,21 @@ const ChatScreen: React.FC = () => {
   const [searchVisible, setSearchVisible] = useState(false);
   const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
   const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});
+  // Service-Status (Gamebox: F5-TTS / Whisper Lade-Status) + Banner-Sichtbarkeit
+  const [serviceStatus, setServiceStatus] = useState<Record<string, {state: string, model?: string, loadSeconds?: number, error?: string}>>({});
+  const [serviceBannerDismissed, setServiceBannerDismissed] = useState(false);
   // Gerätelokale TTS-Config: globaler Toggle (aus Settings) + temporäres Muten (Mund-Button)
   const [ttsDeviceEnabled, setTtsDeviceEnabled] = useState(true);
   const [ttsMuted, setTtsMuted] = useState(false);
   // Gerätelokale XTTS-Voice-Wahl (bevorzugt gegenueber dem globalen Default)
   const localXttsVoiceRef = useRef<string>('');
+  // Geraetelokale TTS-Wiedergabegeschwindigkeit (speed-Param an F5-TTS)
+  const ttsSpeedRef = useRef<number>(TTS_SPEED_DEFAULT);
+  // Spiegelung der TTS-Settings in einer Ref — damit die onMessage-Closure
+  // (useEffect mit []-deps) IMMER die aktuellen Werte sieht. Ohne Ref
+  // bliebe canPlay auf dem Mount-Initial-Wert haengen (mute ignoriert,
+  // oder AsyncStorage-Load nicht beruecksichtigt).
+  const ttsCanPlayRef = useRef<boolean>(true);
 
   const flatListRef = useRef<FlatList>(null);
   const messageIdCounter = useRef(0);
@@ -132,6 +143,7 @@ const ChatScreen: React.FC = () => {
       setTtsMuted(muted === 'true'); // default false
       const voice = await AsyncStorage.getItem('aria_xtts_voice');
       localXttsVoiceRef.current = voice || '';
+      ttsSpeedRef.current = await loadTtsSpeed();
     };
     loadTtsSettings();
     // Poll alle 2s um Settings-Aenderung mitzubekommen (einfache Loesung ohne Context)
@@ -144,6 +156,12 @@ const ChatScreen: React.FC = () => {
     wakeWordService.loadFromStorage().catch(() => {});
   }, []);
 
+  // ttsCanPlayRef live aktuell halten — Closure in onMessage unten liest
+  // darueber statt direkt ttsDeviceEnabled/ttsMuted (sonst stale).
+  useEffect(() => {
+    ttsCanPlayRef.current = ttsDeviceEnabled && !ttsMuted;
+  }, [ttsDeviceEnabled, ttsMuted]);
+
   const toggleMute = useCallback(() => {
     setTtsMuted(prev => {
       const next = !prev;
@@ -296,7 +314,12 @@ const ChatScreen: React.FC = () => {
       }
 
       // TTS-Audio abspielen wenn vorhanden — respektiert geraetelokalen Mute/Disable
-      const canPlay = ttsDeviceEnabled && !ttsMuted;
+      // WICHTIG: via Ref statt direkt state lesen, sonst ist's stale (Closure-Bug).
+      const canPlay = ttsCanPlayRef.current;
+      if (message.type === 'audio_pcm' || (message.type === 'audio' && message.payload.base64)) {
+        console.log('[Chat] audio-msg canPlay=%s (enabled=%s muted=%s)',
+                    canPlay, ttsDeviceEnabled, ttsMuted);
+      }
       if (message.type === 'audio' && message.payload.base64) {
         const b64 = message.payload.base64 as string;
         const refId = (message.payload.messageId as string) || '';
@@ -351,6 +374,24 @@ const ChatScreen: React.FC = () => {
           ToastAndroid.show(`Stimme "${v || 'Standard'}" bereit`, ToastAndroid.SHORT);
         }
       }
+
+      // Gamebox-Bridges (f5tts/whisper) melden Lade-Status — Banner oben
+      if (message.type === ('service_status' as any)) {
+        const p = message.payload as any;
+        const svc = (p?.service as string) || '';
+        if (!svc) return;
+        setServiceStatus(prev => ({
+          ...prev,
+          [svc]: {
+            state: (p?.state as string) || 'unknown',
+            model: p?.model as string | undefined,
+            loadSeconds: p?.loadSeconds as number | undefined,
+            error: p?.error as string | undefined,
+          },
+        }));
+        // Bei neuer Loading-Phase Banner wieder aktivieren
+        if (p?.state === 'loading') setServiceBannerDismissed(false);
+      }
     });
 
     const unsubState = rvs.onStateChange((state) => {
@@ -418,6 +459,7 @@ const ChatScreen: React.FC = () => {
           durationMs: result.durationMs,
           mimeType: result.mimeType,
           voice: localXttsVoiceRef.current,
+          speed: ttsSpeedRef.current,
           ...(location && { location }),
         });
         // resume() wird durch onPlaybackFinished nach ARIAs Antwort getriggert.
@@ -439,7 +481,12 @@ const ChatScreen: React.FC = () => {
   // Wake Word Toggle Handler
   const toggleWakeWord = useCallback(async () => {
     if (wakeWordActive) {
-      wakeWordService.stop();
+      // Vor Porcupine-Stop: eventuelle laufende Aufnahme abbrechen. Sonst
+      // bleibt audioService.recordingState=='recording' haengen und der
+      // normale Aufnahme-Button wirkt nicht mehr (startRecording lehnt
+      // ab weil "Aufnahme laeuft bereits").
+      try { await audioService.stopRecording(); } catch {}
+      await wakeWordService.stop();
       setWakeWordActive(false);
     } else {
       const started = await wakeWordService.start();
@@ -529,6 +576,7 @@ const ChatScreen: React.FC = () => {
     rvs.send('chat', {
       text,
       voice: localXttsVoiceRef.current,
+      speed: ttsSpeedRef.current,
       ...(location && { location }),
     });
   }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments]);
@@ -638,6 +686,7 @@ const ChatScreen: React.FC = () => {
       rvs.send('chat', {
         text: messageText,
         voice: localXttsVoiceRef.current,
+        speed: ttsSpeedRef.current,
         ...(location && { location }),
       });
     }
@@ -712,9 +761,10 @@ const ChatScreen: React.FC = () => {
         ))}
         {/* Text (nicht anzeigen wenn nur "Anhang empfangen" und ein Bild da ist) */}
         {!(item.text === 'Anhang empfangen' && item.attachments?.some(a => a.type === 'image' && a.uri)) && (
-          <Text style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}>
-            {item.text}
-          </Text>
+          <MessageText
+            text={item.text}
+            style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}
+          />
         )}
         {/* Play-Button fuer ARIA-Nachrichten — Cache bevorzugt, sonst Bridge-TTS mit aktueller Engine */}
         {!isUser && item.text.length > 0 && (
@@ -729,6 +779,7 @@ const ChatScreen: React.FC = () => {
                 rvs.send('tts_request' as any, {
                   text: item.text,
                   voice: localXttsVoiceRef.current,
+                  speed: ttsSpeedRef.current,
                   messageId: item.messageId || '',
                 });
               }
@@ -764,6 +815,49 @@ const ChatScreen: React.FC = () => {
         </TouchableOpacity>
       </View>
 
+      {/* Service-Status Banner (Gamebox: F5-TTS / Whisper Lade-Status) */}
+      {(() => {
+        const entries = Object.entries(serviceStatus);
+        if (entries.length === 0 || serviceBannerDismissed) return null;
+        const anyLoading = entries.some(([, v]) => v.state === 'loading');
+        const anyError = entries.some(([, v]) => v.state === 'error');
+        const allReady = !anyLoading && !anyError && entries.every(([, v]) => v.state === 'ready');
+        const bg = anyError ? '#3A1F1F' : anyLoading ? '#3A331F' : '#1F3A2A';
+        const border = anyError ? '#FF3B30' : anyLoading ? '#FFD60A' : '#34C759';
+        const labels: Record<string, string> = { f5tts: 'F5-TTS', whisper: 'Whisper STT' };
+        return (
+          <TouchableOpacity
+            activeOpacity={allReady ? 0.6 : 1.0}
+            onPress={() => { if (allReady) setServiceBannerDismissed(true); }}
+            style={[styles.serviceBanner, { backgroundColor: bg, borderColor: border }]}
+          >
+            {entries.map(([svc, info]) => {
+              let icon = '\u23F3', text = '';
+              if (info.state === 'loading') {
+                text = `${labels[svc] || svc}: laedt${info.model ? ' ' + info.model : ''}...`;
+              } else if (info.state === 'ready') {
+                icon = '\u2705';
+                const sec = info.loadSeconds ? ` (${info.loadSeconds.toFixed(1)}s)` : '';
+                text = `${labels[svc] || svc}: bereit${info.model ? ' ' + info.model : ''}${sec}`;
+              } else if (info.state === 'error') {
+                icon = '\u274C';
+                text = `${labels[svc] || svc}: Fehler ${info.error || ''}`;
+              } else {
+                text = `${labels[svc] || svc}: ${info.state}`;
+              }
+              return (
+                <Text key={svc} style={styles.serviceBannerLine}>
+                  {icon}  {text}
+                </Text>
+              );
+            })}
+            <Text style={styles.serviceBannerHint}>
+              {allReady ? 'Tippen zum Schliessen' : 'Bitte warten...'}
+            </Text>
+          </TouchableOpacity>
+        );
+      })()}
+
       {/* Suchleiste */}
       {searchVisible && (
         <View style={styles.searchBar}>
@@ -978,6 +1072,25 @@ const styles = StyleSheet.create({
     color: '#8888AA',
     fontSize: 12,
   },
+  serviceBanner: {
+    paddingVertical: 8,
+    paddingHorizontal: 12,
+    borderTopWidth: 0,
+    borderBottomWidth: 1,
+    borderLeftWidth: 0,
+    borderRightWidth: 0,
+  },
+  serviceBannerLine: {
+    color: '#FFFFFF',
+    fontSize: 12,
+    lineHeight: 18,
+  },
+  serviceBannerHint: {
+    color: '#AAAACC',
+    fontSize: 10,
+    marginTop: 2,
+    fontStyle: 'italic',
+  },
   messageList: {
     padding: 12,
     paddingBottom: 8,

android/src/screens/SettingsScreen.tsx

@@ -35,6 +35,10 @@ import {
   CONV_WINDOW_MIN_SEC,
   CONV_WINDOW_MAX_SEC,
   CONV_WINDOW_STORAGE_KEY,
+  TTS_SPEED_DEFAULT,
+  TTS_SPEED_MIN,
+  TTS_SPEED_MAX,
+  TTS_SPEED_STORAGE_KEY,
 } from '../services/audio';
 import wakeWordService, {
   BUILTIN_KEYWORDS,
@@ -98,6 +102,7 @@ const SettingsScreen: React.FC = () => {
   const [ttsPrerollSec, setTtsPrerollSec] = useState<number>(TTS_PREROLL_DEFAULT_SEC);
   const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
   const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
+  const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
   const [wakeAccessKey, setWakeAccessKey] = useState<string>('');
   const [wakeAccessKeyVisible, setWakeAccessKeyVisible] = useState(false);
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
@@ -153,6 +158,12 @@ const SettingsScreen: React.FC = () => {
         }
       }
     });
+    AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY).then(saved => {
+      if (saved != null) {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) setTtsSpeed(n);
+      }
+    });
     AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
       if (saved) setWakeAccessKey(saved);
     });
@@ -800,6 +811,38 @@ const SettingsScreen: React.FC = () => {
                 <Text style={styles.prerollButtonText}>+0.5</Text>
               </TouchableOpacity>
             </View>
+
+            <Text style={[styles.toggleLabel, {marginTop: 24}]}>Sprechgeschwindigkeit</Text>
+            <Text style={styles.toggleHint}>
+              Wie schnell ARIA spricht. 1.0 = Normal. Niedriger = langsamer, hoeher = schneller.
+              Wird an F5-TTS als speed-Param uebergeben und pro Geraet gespeichert.
+              Default: {TTS_SPEED_DEFAULT.toFixed(1)}x.
+            </Text>
+            <View style={styles.prerollRow}>
+              <TouchableOpacity
+                style={styles.prerollButton}
+                onPress={() => {
+                  const next = Math.max(TTS_SPEED_MIN, Math.round((ttsSpeed - 0.1) * 10) / 10);
+                  setTtsSpeed(next);
+                  AsyncStorage.setItem(TTS_SPEED_STORAGE_KEY, String(next));
+                }}
+                disabled={ttsSpeed <= TTS_SPEED_MIN}
+              >
+                <Text style={styles.prerollButtonText}>−0.1</Text>
+              </TouchableOpacity>
+              <Text style={styles.prerollValue}>{ttsSpeed.toFixed(1)} x</Text>
+              <TouchableOpacity
+                style={styles.prerollButton}
+                onPress={() => {
+                  const next = Math.min(TTS_SPEED_MAX, Math.round((ttsSpeed + 0.1) * 10) / 10);
+                  setTtsSpeed(next);
+                  AsyncStorage.setItem(TTS_SPEED_STORAGE_KEY, String(next));
+                }}
+                disabled={ttsSpeed >= TTS_SPEED_MAX}
+              >
+                <Text style={styles.prerollButtonText}>+0.1</Text>
+              </TouchableOpacity>
+            </View>
           </View>
         )}
 

android/src/services/audio.ts

@@ -92,6 +92,24 @@ export const CONV_WINDOW_MIN_SEC = 3.0;
 export const CONV_WINDOW_MAX_SEC = 20.0;
 export const CONV_WINDOW_STORAGE_KEY = 'aria_conv_window_sec';
 
+// TTS-Wiedergabegeschwindigkeit — wird pro Geraet gespeichert und an die
+// Bridge mitgegeben (speed-Param im F5-TTS infer()). 1.0 = normal.
+export const TTS_SPEED_DEFAULT = 1.0;
+export const TTS_SPEED_MIN = 0.1;
+export const TTS_SPEED_MAX = 5.0;
+export const TTS_SPEED_STORAGE_KEY = 'aria_tts_speed';
+
+export async function loadTtsSpeed(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) return n;
+    }
+  } catch {}
+  return TTS_SPEED_DEFAULT;
+}
+
 export async function loadConvWindowMs(): Promise<number> {
   try {
     const raw = await AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY);
@@ -125,7 +143,7 @@ const MAX_RECORDING_MS = 120000;
 // Pre-Roll: Wie lange Audio im AudioTrack-Buffer liegt bevor play() startet.
 // Einstellbar via Diagnostic/Settings (Key: aria_tts_preroll_sec).
 export const TTS_PREROLL_DEFAULT_SEC = 3.5;
-export const TTS_PREROLL_MIN_SEC = 1.0;
+export const TTS_PREROLL_MIN_SEC = 0;     // 0 = sofort abspielen (F5-TTS ist schnell genug)
 export const TTS_PREROLL_MAX_SEC = 6.0;
 export const TTS_PREROLL_STORAGE_KEY = 'aria_tts_preroll_sec';
 
@@ -178,6 +196,8 @@ class AudioService {
   private lastSpeechTime: number = 0;
   private vadTimer: ReturnType<typeof setInterval> | null = null;
   private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
+  // Latch damit der Silence-Callback pro Aufnahme genau einmal feuert
+  private silenceFired: boolean = false;
   private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor() {
@@ -287,33 +307,46 @@ class AudioService {
       // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
       AudioFocus?.requestExclusive().catch(() => {});
 
-      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar)
+      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar).
+      // WICHTIG: jeder Trigger (VAD-Stille / Max-Dauer / No-Speech-Window)
+      // disable SOFORT den VAD-Flag und clear den Timer, BEVOR die Listener
+      // gefeuert werden. Sonst feuert das setInterval weiter alle 200ms und
+      // ruft stopRecording parallel auf → audio-recorder-player crasht.
       this.vadEnabled = autoStop;
+      this.silenceFired = false;
+      const fireSilenceOnce = (reason: string) => {
+        if (this.silenceFired) return;
+        this.silenceFired = true;
+        this.vadEnabled = false;
+        if (this.vadTimer) { clearInterval(this.vadTimer); this.vadTimer = null; }
+        if (this.maxDurationTimer) { clearTimeout(this.maxDurationTimer); this.maxDurationTimer = null; }
+        if (this.noSpeechTimer) { clearTimeout(this.noSpeechTimer); this.noSpeechTimer = null; }
+        console.log('[Audio] Silence-Fire: %s', reason);
+        this.silenceListeners.forEach(cb => {
+          try { cb(); } catch (e) { console.warn('[Audio] silence listener err:', e); }
+        });
+      };
       if (autoStop) {
         const vadSilenceMs = await loadVadSilenceMs();
         console.log('[Audio] VAD-Stille:', vadSilenceMs, 'ms');
         this.vadTimer = setInterval(() => {
           const silenceDuration = Date.now() - this.lastSpeechTime;
           if (silenceDuration >= vadSilenceMs) {
-            console.log(`[Audio] VAD: ${silenceDuration}ms Stille — Auto-Stop`);
-            this.silenceListeners.forEach(cb => cb());
+            fireSilenceOnce(`VAD ${silenceDuration}ms Stille`);
           }
         }, 200);
         // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
         this.maxDurationTimer = setTimeout(() => {
-          console.warn(`[Audio] Max-Dauer ${MAX_RECORDING_MS}ms erreicht — Zwangs-Stop`);
-          this.silenceListeners.forEach(cb => cb());
+          fireSilenceOnce(`Max-Dauer ${MAX_RECORDING_MS}ms`);
         }, MAX_RECORDING_MS);
       }
 
       // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
-      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie),
-      // ChatScreen erkennt das und beendet die Konversation.
+      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie).
       if (noSpeechTimeoutMs > 0) {
         this.noSpeechTimer = setTimeout(() => {
           if (!this.speechDetected && this.recordingState === 'recording') {
-            console.log(`[Audio] Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache — Stop`);
-            this.silenceListeners.forEach(cb => cb());
+            fireSilenceOnce(`Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache`);
           }
         }, noSpeechTimeoutMs);
       }
@@ -441,6 +474,13 @@ class AudioService {
       console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
       return '';
     }
+    // Debug-Log bei Chunk 0 eines neuen Streams — damit man im adb logcat
+    // sieht warum der Auto-Playback greift oder nicht.
+    if ((payload.chunk ?? 0) === 0 && !this.pcmStreamActive) {
+      console.log('[Audio] PCM-Stream start: silent=%s messageId=%s sr=%s ch=%s',
+                  silent, payload.messageId || '(none)',
+                  payload.sampleRate, payload.channels);
+    }
 
     const messageId = payload.messageId || '';
     const sampleRate = payload.sampleRate || 24000;

android/src/services/wakeword.ts

@@ -90,12 +90,32 @@ class WakeWordService {
     if (this.initInProgress) return this.initInProgress;
     this.initInProgress = (async () => {
       try {
-        const { PorcupineManager } = require('@picovoice/porcupine-react-native');
-        // Built-In Keyword-Identifier sind lower-case strings im SDK
+        const porcupineRN = require('@picovoice/porcupine-react-native');
+        const { PorcupineManager, BuiltInKeywords } = porcupineRN;
+        // Manche Porcupine-Versionen wollen das BuiltInKeywords-Enum (Objekt
+        // mit keys wie JARVIS, COMPUTER, HEY_GOOGLE), andere akzeptieren
+        // den String direkt. Mappen mit Fallback auf String:
+        const enumKey = this.keyword.toUpperCase().replace(/\s+/g, '_');
+        const kw = (BuiltInKeywords && BuiltInKeywords[enumKey]) || this.keyword;
+        console.log('[WakeWord] Porcupine init: keyword=%s (resolved=%s)',
+                    this.keyword, typeof kw === 'string' ? kw : '[enum]');
         this.porcupine = await PorcupineManager.fromBuiltInKeywords(
           this.accessKey,
-          [this.keyword],
-          (_keywordIndex: number) => this.onWakeDetected(),
+          [kw],
+          (keywordIndex: number) => {
+            console.log('[WakeWord] Porcupine callback fired (index=%d)', keywordIndex);
+            this.onWakeDetected().catch(err =>
+              console.warn('[WakeWord] onWakeDetected crashed:', err));
+          },
+          // Error handler (wenn Porcupine im Background-Thread crashed,
+          // z.B. beim Audio-Engine-Konflikt mit audio-recorder-player)
+          (error: any) => {
+            console.warn('[WakeWord] Porcupine runtime error:', error?.message || error);
+            // Nicht in Loop crashen — state zurueck auf off damit der User
+            // mit dem Aufnahme-Button wieder normal arbeiten kann
+            this.setState('off');
+            this.disposePorcupine().catch(() => {});
+          },
         );
         console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
         return true;

bridge/aria_bridge.py

@@ -541,9 +541,16 @@ class ARIABridge:
         # Wird fuer die direkt folgende ARIA-Antwort genutzt und dann zurueckgesetzt.
         # So kann jedes Geraet seine bevorzugte Stimme bekommen (pro Request).
         self._next_voice_override: Optional[str] = None
+        # Gleiche Logik fuer die Wiedergabegeschwindigkeit (F5-TTS speed-Param,
+        # App-Setting aria_tts_speed, 1.0 = normal).
+        self._next_speed_override: Optional[float] = None
         # STT-Requests die aktuell auf Antwort von der whisper-bridge (Gamebox) warten.
         # requestId → Future mit dem Text (oder None bei Fehler).
         self._pending_stt: dict[str, asyncio.Future] = {}
+        # whisper-bridge service_status: True wenn ready, False/None wenn loading/unbekannt.
+        # Beeinflusst das Timeout fuer stt_request — bei "loading" warten wir laenger,
+        # weil das Modell beim ersten Request noch ~1-2 Min runtergeladen werden kann.
+        self._remote_stt_ready: bool = False
 
     def initialize(self) -> None:
         """Initialisiert alle Komponenten.
@@ -907,6 +914,12 @@ class ARIABridge:
             logger.info("[core] Nutze Voice-Override: %s", self._next_voice_override)
             self._next_voice_override = None
 
+        # Speed ebenfalls aus App-Override nehmen (fallback 1.0)
+        xtts_speed = self._next_speed_override or 1.0
+        if self._next_speed_override:
+            logger.info("[core] Nutze Speed-Override: %.2fx", self._next_speed_override)
+            self._next_speed_override = None
+
         tts_text = tts_text_preview or text
         if not tts_text:
             logger.info("[core] TTS-Text leer nach Cleanup — uebersprungen")
@@ -922,6 +935,7 @@ class ARIABridge:
                 "payload": {
                     "text": tts_text,
                     "voice": xtts_voice,
+                    "speed": xtts_speed,
                     "language": "de",
                     "requestId": xtts_request_id,
                     "messageId": message_id,
@@ -1159,6 +1173,13 @@ class ARIABridge:
             if voice_override:
                 self._next_voice_override = voice_override
                 logger.info("[rvs] Voice-Override fuer naechste Antwort: %s", voice_override)
+            # Speed-Override (TTS-Wiedergabegeschwindigkeit, pro Geraet)
+            try:
+                speed = float(payload.get("speed", 0) or 0)
+                if 0.1 <= speed <= 5.0:
+                    self._next_speed_override = speed
+            except (TypeError, ValueError):
+                pass
             if text:
                 logger.info("[rvs] App-Chat: '%s'", text[:80])
                 await self.send_to_core(text, source="app")
@@ -1211,8 +1232,14 @@ class ARIABridge:
             if not text:
                 return
             tts_text = clean_text_for_tts(text) or text
-            # Voice aus App-Payload gewinnt, sonst global
+            # Voice + Speed aus App-Payload gewinnen, sonst global/default
             xtts_voice = payload.get("voice", "") or getattr(self, 'xtts_voice', '')
+            try:
+                xtts_speed = float(payload.get("speed", 0) or 0)
+                if not (0.1 <= xtts_speed <= 5.0):
+                    xtts_speed = 1.0
+            except (TypeError, ValueError):
+                xtts_speed = 1.0
             try:
                 xtts_request_id = str(uuid.uuid4())
                 if message_id:
@@ -1222,6 +1249,7 @@ class ARIABridge:
                     "payload": {
                         "text": tts_text,
                         "voice": xtts_voice,
+                        "speed": xtts_speed,
                         "language": "de",
                         "requestId": xtts_request_id,
                         "messageId": message_id,
@@ -1420,6 +1448,12 @@ class ARIABridge:
             if voice_override:
                 self._next_voice_override = voice_override
                 logger.info("[rvs] Voice-Override (via Audio): %s", voice_override)
+            try:
+                speed = float(payload.get("speed", 0) or 0)
+                if 0.1 <= speed <= 5.0:
+                    self._next_speed_override = speed
+            except (TypeError, ValueError):
+                pass
             logger.info("[rvs] Audio empfangen: %s, %dms, %dKB",
                         mime_type, duration_ms, len(audio_b64) // 1365)
             asyncio.create_task(self._process_app_audio(audio_b64, mime_type))
@@ -1442,13 +1476,41 @@ class ARIABridge:
                 future.set_result(text)
             return
 
+        elif msg_type == "service_status":
+            # Gamebox-Bridges (whisper / f5tts) melden ihren Lade-Status.
+            # Wir nutzen das fuer den dynamischen STT-Timeout: solange whisper
+            # im 'loading' steckt, geben wir der Bridge mehr Zeit (Modell-Download
+            # kann 1-2 Min dauern), statt nach 45s lokal zu fallbacken.
+            svc = payload.get("service", "")
+            state = payload.get("state", "")
+            if svc == "whisper":
+                was_ready = self._remote_stt_ready
+                self._remote_stt_ready = (state == "ready")
+                if self._remote_stt_ready != was_ready:
+                    logger.info("[rvs] whisper-bridge -> %s", state)
+            return
+
+        elif msg_type == "config_request":
+            # Eine andere Bridge (whisper/f5tts) bittet um die aktuelle Voice-
+            # Config — passiert wenn sie sich connected, weil sie sonst die
+            # Diagnostic-Settings nicht kennt. Wir broadcasten die persistierte
+            # Config (auch beim normalen Connect von aria-bridge selber, aber
+            # da war eventuell die andere Bridge noch nicht connected).
+            requester = payload.get("service", "?")
+            logger.info("[rvs] config_request von %s — broadcaste Voice-Config", requester)
+            asyncio.create_task(self._broadcast_persisted_config())
+            return
+
         else:
             logger.debug("[rvs] Unbekannter Typ: %s", msg_type)
 
     # STT-Orchestrierung: zuerst Remote (Gamebox), Fallback lokal.
-    # Timeout grosszuegig gewaehlt, damit auch ein erstmaliger Modell-Load
-    # auf der Gamebox (bis ~30s bei large-v3) durchgeht.
-    _STT_REMOTE_TIMEOUT_S = 45.0
+    # Zwei Timeouts:
+    #   ready=True   → 45s reicht selbst fuer lange Audios
+    #   ready=False  → 300s, weil das Modell evtl. noch heruntergeladen wird
+    #                  (large-v3 ~3GB, kann auf der Gamebox 1-2 Min dauern).
+    _STT_REMOTE_TIMEOUT_READY_S = 45.0
+    _STT_REMOTE_TIMEOUT_LOADING_S = 300.0
 
     async def _process_app_audio(self, audio_b64: str, mime_type: str) -> None:
         """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal."""
@@ -1514,7 +1576,12 @@ class ARIABridge:
             if not ok:
                 logger.warning("[rvs] stt_request konnte nicht gesendet werden — skip Remote")
                 return None
-            return await asyncio.wait_for(future, timeout=self._STT_REMOTE_TIMEOUT_S)
+            timeout_s = (self._STT_REMOTE_TIMEOUT_READY_S
+                         if self._remote_stt_ready
+                         else self._STT_REMOTE_TIMEOUT_LOADING_S)
+            logger.info("[rvs] STT-Timeout %ds (whisper-bridge %s)",
+                        int(timeout_s), "ready" if self._remote_stt_ready else "loading")
+            return await asyncio.wait_for(future, timeout=timeout_s)
         except asyncio.TimeoutError:
             logger.warning("[rvs] Remote-STT Timeout (%.0fs)", self._STT_REMOTE_TIMEOUT_S)
             return None

diagnostic/index.html

@@ -127,6 +127,43 @@
   </style>
 </head>
 <body>
+  <!-- Service-Status Banner unten rechts (Gamebox: F5-TTS / Whisper Lade-Status) -->
+  <div id="service-status-banner" style="display:none;position:fixed;bottom:16px;right:16px;z-index:999;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:8px;padding:10px 14px;font-size:12px;color:#fff;min-width:240px;max-width:360px;box-shadow:0 4px 14px rgba(0,0,0,0.5);">
+    <div style="display:flex;align-items:flex-start;gap:8px;">
+      <span id="service-status-icon" style="font-size:18px;line-height:1;">&#x23F3;</span>
+      <div id="service-status-list" style="flex:1;display:flex;flex-direction:column;gap:6px;"></div>
+      <button id="service-status-close" onclick="document.getElementById('service-status-banner').style.display='none'" style="background:none;border:none;color:#666680;font-size:16px;cursor:pointer;padding:0;line-height:1;display:none;">&times;</button>
+    </div>
+  </div>
+
+  <!-- Voice-Preview Modal -->
+  <div id="voice-preview-modal" style="display:none;position:fixed;inset:0;z-index:1000;background:rgba(0,0,0,0.7);align-items:center;justify-content:center;">
+    <div style="background:#1A1A2E;border:1px solid #2A2A3E;border-radius:10px;padding:20px;max-width:560px;width:90%;display:flex;flex-direction:column;gap:12px;">
+      <div style="display:flex;align-items:center;justify-content:space-between;">
+        <h3 style="margin:0;color:#fff;">Stimmen-Preview: <span id="voice-preview-name">—</span></h3>
+        <button onclick="closeVoicePreview()" style="background:none;border:none;color:#8888AA;font-size:22px;cursor:pointer;">&times;</button>
+      </div>
+      <textarea id="voice-preview-text" rows="4"
+        style="background:#0D0D1A;border:1px solid #2A2A3E;border-radius:6px;padding:10px;color:#fff;font-size:13px;resize:vertical;"></textarea>
+
+      <div style="display:flex;align-items:center;gap:10px;font-size:12px;color:#8888AA;">
+        <span style="min-width:120px;">Geschwindigkeit:</span>
+        <button onclick="adjustPreviewSpeed(-0.1)" class="btn secondary" style="padding:4px 10px;font-size:12px;">−0.1</button>
+        <span id="voice-preview-speed-value" style="min-width:52px;text-align:center;color:#fff;font-weight:600;">1.0 x</span>
+        <button onclick="adjustPreviewSpeed(0.1)" class="btn secondary" style="padding:4px 10px;font-size:12px;">+0.1</button>
+        <span style="color:#555570;font-size:11px;">(nur fuer dieses Modal, wird nicht gespeichert)</span>
+      </div>
+
+      <div style="display:flex;gap:8px;align-items:center;">
+        <button id="voice-preview-play" onclick="playVoicePreview()" class="btn primary" style="padding:8px 16px;">
+          ▶ Abspielen
+        </button>
+        <span id="voice-preview-status" style="color:#8888AA;font-size:11px;flex:1;"></span>
+      </div>
+      <audio id="voice-preview-audio" controls style="width:100%;display:none;"></audio>
+    </div>
+  </div>
+
   <!-- Disk-Space Warnung (dynamisch gesetzt) -->
   <div id="disk-banner" style="display:none;position:sticky;top:0;z-index:500;padding:10px 14px;border-radius:0;margin:-16px -16px 12px -16px;font-size:13px;">
     <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap;">
@@ -460,23 +497,25 @@
               Hardcoded Defaults: F5TTS_v1_Base, cfg_strength=2.5, nfe_step=32.
             </div>
 
-            <label style="color:#8888AA;font-size:12px;">Modell-ID:</label>
+            <label style="color:#8888AA;font-size:12px;">
+              Modell-Architektur (F5TTS_v1_Base = Default multilingual, F5TTS_Base = fuer die meisten Fine-Tunes):
+            </label>
             <input type="text" id="diag-f5tts-model"
               placeholder="F5TTS_v1_Base"
               style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
 
             <label style="color:#8888AA;font-size:12px;">
-              Custom Checkpoint (HF-Repo "user/repo" oder Container-Pfad, leer = Default):
+              Custom Checkpoint — HF-Pfad (hf://user/repo/file) oder lokaler Container-Pfad. Leer = Default.
             </label>
             <input type="text" id="diag-f5tts-ckpt"
-              placeholder="z.B. aoxo/F5-TTS-German"
+              placeholder="z.B. hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors"
               style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
 
             <label style="color:#8888AA;font-size:12px;">
-              Custom Vocab (passend zum Checkpoint, optional):
+              Custom Vocab — muss zum Checkpoint passen. Leer = Default.
             </label>
             <input type="text" id="diag-f5tts-vocab"
-              placeholder="leer = Default"
+              placeholder="z.B. hf://aihpi/F5-TTS-German/vocab.txt"
               style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
 
             <div style="display:flex;gap:12px;">
@@ -914,6 +953,29 @@
           return;
         }
 
+        if (msg.type === 'service_status') {
+          updateServiceStatus(msg.payload || {});
+          return;
+        }
+
+        if (msg.type === 'voice_preview_audio') {
+          const statusEl = document.getElementById('voice-preview-status');
+          const audio = document.getElementById('voice-preview-audio');
+          const playBtn = document.getElementById('voice-preview-play');
+          if (playBtn) playBtn.disabled = false;
+          if (msg.error) {
+            if (statusEl) statusEl.textContent = '❌ Fehler: ' + msg.error;
+            return;
+          }
+          if (msg.base64 && audio) {
+            audio.src = 'data:audio/wav;base64,' + msg.base64;
+            audio.style.display = 'block';
+            audio.play().catch(() => {});
+            if (statusEl) statusEl.textContent = '✅ fertig';
+          }
+          return;
+        }
+
         if (msg.type === 'voice_ready') {
           const v = msg.payload?.voice || '';
           const err = msg.payload?.error;
@@ -1452,6 +1514,68 @@
       'Glob': '\uD83D\uDCC1 Dateien suchen',
       'Agent': '\uD83E\uDD16 Sub-Agent',
     };
+    // ── Service-Status Banner (Gamebox: F5-TTS / Whisper Lade-Status) ──
+    // Aggregiert die Status-Infos der Bridges. Wenn irgendwas am Laden
+    // ist, zeigt das Banner unten rechts. Sobald alles auf 'ready' ist,
+    // bleibt's einen Moment und wird dann vom User weggeklickt (oder
+    // nach 8s automatisch).
+    const _serviceState = {}; // { f5tts: {state, model, ...}, whisper: {...} }
+    let _serviceFadeTimer = null;
+    function updateServiceStatus(p) {
+      const svc = p.service || '?';
+      _serviceState[svc] = p;
+
+      const banner = document.getElementById('service-status-banner');
+      const list = document.getElementById('service-status-list');
+      const icon = document.getElementById('service-status-icon');
+      const closeBtn = document.getElementById('service-status-close');
+
+      // Liste neu aufbauen
+      list.innerHTML = '';
+      let anyLoading = false, anyError = false;
+      const labels = { f5tts: 'F5-TTS', whisper: 'Whisper STT' };
+      for (const [s, info] of Object.entries(_serviceState)) {
+        const row = document.createElement('div');
+        row.style.cssText = 'display:flex;align-items:center;gap:6px;';
+        let dot = '⚫', color = '#666680', text = '';
+        if (info.state === 'loading') {
+          dot = '⏳'; color = '#FFD60A'; anyLoading = true;
+          text = `${labels[s] || s}: laedt${info.model ? ' ' + info.model : ''}...`;
+        } else if (info.state === 'ready') {
+          dot = '✅'; color = '#34C759';
+          const sec = info.loadSeconds ? ` (${info.loadSeconds.toFixed(1)}s)` : '';
+          text = `${labels[s] || s}: bereit${info.model ? ' ' + info.model : ''}${sec}`;
+        } else if (info.state === 'error') {
+          dot = '❌'; color = '#FF3B30'; anyError = true;
+          text = `${labels[s] || s}: Fehler ${info.error || ''}`;
+        } else {
+          text = `${labels[s] || s}: ${info.state}`;
+        }
+        row.innerHTML = `<span style="color:${color}">${dot}</span><span>${text}</span>`;
+        list.appendChild(row);
+      }
+
+      // Icon spiegelt Gesamt-Status
+      if (anyError) icon.innerHTML = '&#x274C;';
+      else if (anyLoading) icon.innerHTML = '&#x23F3;';
+      else icon.innerHTML = '&#x2705;';
+
+      banner.style.display = 'block';
+
+      // Wenn alles ready (kein Loading, kein Error): X-Button anzeigen
+      // + nach 8s automatisch wegfaden
+      if (!anyLoading && !anyError) {
+        closeBtn.style.display = 'block';
+        clearTimeout(_serviceFadeTimer);
+        _serviceFadeTimer = setTimeout(() => {
+          banner.style.display = 'none';
+        }, 8000);
+      } else {
+        closeBtn.style.display = 'none';
+        clearTimeout(_serviceFadeTimer);
+      }
+    }
+
     function updateThinkingIndicator(msg) {
       const indicators = [
         document.getElementById('thinking-indicator'),
@@ -1501,16 +1625,75 @@
       html += '<div style="display:flex;flex-direction:column;gap:4px;">';
       for (const v of voices) {
         const esc = (s) => String(s).replace(/[&<>"']/g, c => ({ "&":"&amp;", "<":"&lt;", ">":"&gt;", '"':"&quot;", "'":"&#39;" }[c]));
+        const jsName = esc(v.name).replace(/'/g, "\\'");
         html += `<div style="display:flex;align-items:center;gap:8px;background:#1E1E2E;border-radius:4px;padding:4px 8px;font-size:12px;">`
               + `<span style="flex:1;color:#E0E0F0;">${esc(v.name)}</span>`
               + `<span style="color:#555570;font-size:10px;">${(v.size/1024).toFixed(0)}KB</span>`
-              + `<button class="btn secondary" onclick="deleteXttsVoice('${esc(v.name).replace(/'/g, "\\'")}')" style="padding:2px 8px;font-size:10px;color:#FF6B6B;" title="Stimme loeschen">X</button>`
+              + `<button class="btn secondary" onclick="openVoicePreview('${jsName}')" style="padding:2px 8px;font-size:12px;" title="Stimme anhoeren">▶</button>`
+              + `<button class="btn secondary" onclick="deleteXttsVoice('${jsName}')" style="padding:2px 8px;font-size:10px;color:#FF6B6B;" title="Stimme loeschen">X</button>`
               + `</div>`;
       }
       html += '</div>';
       box.innerHTML = html;
     }
 
+    // ── Voice Preview Modal ─────────────────────────
+    const VOICE_PREVIEW_DEFAULT = 'Hallo, ich bin ARIA. Das hier ist ein kleiner Test damit du meine Stimme beurteilen kannst.';
+    const PREVIEW_SPEED_DEFAULT = 1.0;
+    const PREVIEW_SPEED_MIN = 0.1;
+    const PREVIEW_SPEED_MAX = 5.0;
+    let currentPreviewVoice = '';
+    let currentPreviewSpeed = PREVIEW_SPEED_DEFAULT;
+
+    function _refreshPreviewSpeedLabel() {
+      const el = document.getElementById('voice-preview-speed-value');
+      if (el) el.textContent = currentPreviewSpeed.toFixed(1) + ' x';
+    }
+
+    function adjustPreviewSpeed(delta) {
+      const next = Math.round((currentPreviewSpeed + delta) * 10) / 10;
+      if (next < PREVIEW_SPEED_MIN || next > PREVIEW_SPEED_MAX) return;
+      currentPreviewSpeed = next;
+      _refreshPreviewSpeedLabel();
+    }
+
+    function openVoicePreview(name) {
+      currentPreviewVoice = name;
+      // Speed bei jedem Oeffnen zuruecksetzen — bewusst kein persist
+      currentPreviewSpeed = PREVIEW_SPEED_DEFAULT;
+      _refreshPreviewSpeedLabel();
+      document.getElementById('voice-preview-name').textContent = name;
+      // Text bei jedem Oeffnen zuruecksetzen
+      document.getElementById('voice-preview-text').value = VOICE_PREVIEW_DEFAULT;
+      document.getElementById('voice-preview-status').textContent = '';
+      const audio = document.getElementById('voice-preview-audio');
+      audio.style.display = 'none';
+      audio.src = '';
+      document.getElementById('voice-preview-modal').style.display = 'flex';
+    }
+
+    function closeVoicePreview() {
+      document.getElementById('voice-preview-modal').style.display = 'none';
+      const audio = document.getElementById('voice-preview-audio');
+      try { audio.pause(); } catch {}
+    }
+
+    function playVoicePreview() {
+      const text = (document.getElementById('voice-preview-text').value || '').trim();
+      if (!text) {
+        document.getElementById('voice-preview-status').textContent = 'Text leer';
+        return;
+      }
+      document.getElementById('voice-preview-status').textContent = '⏳ Rendere...';
+      document.getElementById('voice-preview-play').disabled = true;
+      send({
+        action: 'preview_voice',
+        voice: currentPreviewVoice,
+        text,
+        speed: currentPreviewSpeed,
+      });
+    }
+
     function deleteXttsVoice(name) {
       if (!confirm(`Stimme "${name}" endgueltig loeschen?`)) return;
       send({ action: 'xtts_delete_voice', name });

diagnostic/server.js

@@ -637,6 +637,25 @@ function connectRVS(forcePlain) {
           log("info", "rvs", `Voice "${v || "default"}" geladen${ms ? ` in ${(ms/1000).toFixed(1)}s` : ""}`);
         }
         broadcast({ type: "voice_ready", payload: msg.payload });
+      } else if (msg.type === "service_status") {
+        // Gamebox-Bridges (f5tts/whisper) melden ihren Lade-Status —
+        // an Browser durchreichen fuer das Banner unten rechts
+        const svc = msg.payload?.service || "?";
+        const state = msg.payload?.state || "?";
+        const model = msg.payload?.model || "";
+        const sec = msg.payload?.loadSeconds;
+        const err = msg.payload?.error;
+        if (err) {
+          log("warn", "rvs", `service_status ${svc}: ${err}`);
+        } else if (state === "ready" && sec) {
+          log("info", "rvs", `service_status ${svc} ready (${model}, ${sec.toFixed(1)}s)`);
+        } else {
+          log("info", "rvs", `service_status ${svc} ${state}${model ? ` (${model})` : ""}`);
+        }
+        broadcast({ type: "service_status", payload: msg.payload });
+      } else if (msg.type === "audio_pcm" && msg.payload && _previewPending.size > 0) {
+        // PCM-Chunks einer laufenden Voice-Preview — sammeln + WAV bauen
+        _handlePreviewChunk(msg.payload);
       } else {
         log("debug", "rvs", `Nachricht: ${JSON.stringify(msg).slice(0, 150)}`);
       }
@@ -1423,19 +1442,14 @@ wss.on("connection", (ws) => {
           xttsVoice: msg.xttsVoice || "",
         };
         if (msg.whisperModel !== undefined) voiceConfig.whisperModel = msg.whisperModel;
-        // F5-TTS Tuning-Felder — leere Strings entfernen damit der Default greift
-        if (msg.f5ttsModel !== undefined) {
-          if (msg.f5ttsModel) voiceConfig.f5ttsModel = msg.f5ttsModel;
-          else delete voiceConfig.f5ttsModel;
-        }
-        if (msg.f5ttsCkptFile !== undefined) {
-          if (msg.f5ttsCkptFile) voiceConfig.f5ttsCkptFile = msg.f5ttsCkptFile;
-          else delete voiceConfig.f5ttsCkptFile;
-        }
-        if (msg.f5ttsVocabFile !== undefined) {
-          if (msg.f5ttsVocabFile) voiceConfig.f5ttsVocabFile = msg.f5ttsVocabFile;
-          else delete voiceConfig.f5ttsVocabFile;
-        }
+        // F5-TTS Tuning-Felder — immer mit dem vom User gesendeten Wert setzen,
+        // auch leeren String. Leer = "reset auf Hard-Default". Sonst merkt die
+        // Bridge nicht dass der User den Wert loeschen wollte (absent key war
+        // vorher 'keep current' semantik → BigVGAN blieb drin obwohl User
+        // leer eingetragen hatte).
+        if (msg.f5ttsModel !== undefined)     voiceConfig.f5ttsModel = msg.f5ttsModel || "";
+        if (msg.f5ttsCkptFile !== undefined)  voiceConfig.f5ttsCkptFile = msg.f5ttsCkptFile || "";
+        if (msg.f5ttsVocabFile !== undefined) voiceConfig.f5ttsVocabFile = msg.f5ttsVocabFile || "";
         if (msg.f5ttsCfgStrength !== undefined && !isNaN(msg.f5ttsCfgStrength)) {
           voiceConfig.f5ttsCfgStrength = msg.f5ttsCfgStrength;
         }
@@ -1454,6 +1468,8 @@ wss.on("connection", (ws) => {
         handleSaveTriggers(ws, msg.triggers || []);
       } else if (msg.action === "test_tts") {
         handleTestTTS(ws, msg.text || "Test");
+      } else if (msg.action === "preview_voice") {
+        handleVoicePreview(ws, msg.voice || "", msg.text || "Hallo.", msg.speed);
       } else if (msg.action === "check_tts") {
         handleCheckTTS(ws);
       } else if (msg.action === "check_desktop") {
@@ -1626,6 +1642,98 @@ async function handleSaveTriggers(clientWs, triggers) {
 }
 
 // ── TTS Diagnose (XTTS) ───────────────────────────────
+// ── Voice Preview ────────────────────────────────────────
+// Sammelt audio_pcm Chunks einer Preview-Anfrage, baut am Ende eine WAV
+// und schickt sie base64-kodiert an den Browser-Client.
+//
+// Map requestId → { clientWs, chunks: [Buffer], sampleRate, channels }
+const _previewPending = new Map();
+
+function _buildWavFromPcm(pcmBuf, sampleRate, channels) {
+  const bitsPerSample = 16;
+  const byteRate = sampleRate * channels * bitsPerSample / 8;
+  const blockAlign = channels * bitsPerSample / 8;
+  const dataSize = pcmBuf.length;
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataSize, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);            // subchunk1 size
+  header.writeUInt16LE(1, 20);             // PCM
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(bitsPerSample, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataSize, 40);
+  return Buffer.concat([header, pcmBuf]);
+}
+
+function _handlePreviewChunk(payload) {
+  const reqId = payload?.requestId || "";
+  const entry = _previewPending.get(reqId);
+  if (!entry) return;
+  if (payload.base64) {
+    try { entry.chunks.push(Buffer.from(payload.base64, "base64")); } catch {}
+  }
+  if (!entry.sampleRate && payload.sampleRate) entry.sampleRate = payload.sampleRate;
+  if (!entry.channels && payload.channels) entry.channels = payload.channels;
+  if (payload.final) {
+    _previewPending.delete(reqId);
+    try {
+      const pcm = Buffer.concat(entry.chunks);
+      const wav = _buildWavFromPcm(pcm, entry.sampleRate || 24000, entry.channels || 1);
+      const b64 = wav.toString("base64");
+      if (entry.clientWs && entry.clientWs.readyState === 1) {
+        entry.clientWs.send(JSON.stringify({
+          type: "voice_preview_audio",
+          base64: b64,
+          size: wav.length,
+        }));
+      }
+    } catch (err) {
+      if (entry.clientWs && entry.clientWs.readyState === 1) {
+        entry.clientWs.send(JSON.stringify({
+          type: "voice_preview_audio",
+          error: err.message,
+        }));
+      }
+    }
+  }
+}
+
+async function handleVoicePreview(clientWs, voice, text, speed) {
+  try {
+    // Speed clampen — Browser-Slider ist 0.1-5.0
+    let spd = parseFloat(speed);
+    if (!isFinite(spd) || spd < 0.1 || spd > 5.0) spd = 1.0;
+    const requestId = crypto.randomUUID();
+    _previewPending.set(requestId, { clientWs, chunks: [], sampleRate: 0, channels: 0 });
+    // Timeout safety net
+    setTimeout(() => {
+      if (_previewPending.has(requestId)) {
+        _previewPending.delete(requestId);
+        if (clientWs && clientWs.readyState === 1) {
+          clientWs.send(JSON.stringify({
+            type: "voice_preview_audio",
+            error: "Timeout (60s) — keine Antwort vom f5tts-bridge",
+          }));
+        }
+      }
+    }, 60000);
+    log("info", "server", `Voice-Preview: voice="${voice}" speed=${spd.toFixed(1)}x text="${text.slice(0, 60)}"`);
+    sendToRVS_raw({
+      type: "xtts_request",
+      payload: { text, language: "de", requestId, voice, speed: spd },
+      timestamp: Date.now(),
+    });
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "voice_preview_audio", error: err.message }));
+  }
+}
+
 async function handleTestTTS(clientWs, text) {
   try {
     log("info", "server", `TTS-Test via XTTS: "${text}"`);

issue.md

@@ -70,22 +70,34 @@
 - [x] VAD-Stille einstellbar in App-Settings (1.0-8.0s, Default 2.8s)
 - [x] MAX_RECORDING auf 120s — laengere Erklaerungen moeglich
 - [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
+- [x] F5-TTS: Referenz-WAV-Preprocessing — Loudness-Normalisierung -16 LUFS + Silence-Trim + 10s Clip fuer konsistente Cloning-Quali
+- [x] F5-TTS: deutsches Fine-Tune (aihpi/F5-TTS-German, Vocos-Variante) via hf:// Pfad in Diagnostic konfigurierbar
+- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
+- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
+- [x] Dynamischer STT-Timeout in aria-bridge: 300s waehrend whisper-bridge 'loading', 45s wenn 'ready'
+- [x] service_status Broadcasts: f5tts/whisper melden Lade-Status, Banner in Diagnostic (unten rechts) + App (oben)
+- [x] config_request Pattern: Bridges fragen beim Connect die aktuelle Voice-Config an, aria-bridge antwortet
+- [x] F5-TTS Tuning via Diagnostic (Modell-ID, Checkpoint, cfg_strength, nfe_step) statt ENV-Vars — Hot-Reload bei Modell-Wechsel
+- [x] Conversation-Window: Gespraechsmodus endet nach X Sekunden Stille (1.0-20.0s, Default 8s, einstellbar in Settings)
+- [x] Porcupine Wake-Word-Integration in der App (Built-In Keywords + Custom spaeter, per Geraet einstellbar)
+- [x] HF-Cache als Bind-Mount statt Docker Volume — kein .vhdx-Bloat auf Docker Desktop / Windows
+- [x] cleanup-windows.ps1 / .bat: VHDX-Cleanup via diskpart (ohne Hyper-V) mit Self-Elevation
+- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
+- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
+- [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
+- [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
+- [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
 
 ## Offen
 
 ### Bugs
-- [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)
+- [ ] App: Wake-Word "jarvis" triggert nicht zuverlaessig (Porcupine-Debugging via ADB-Logcat ausstehend)
+- [ ] App: Stuerzt beim Lauschen ab, eventuell bei Nebengeraeuschen (Porcupine + Mic-Race, errorCallback haelt's jetzt zurueck — Dauertest ausstehend)
 
 ### App Features
-- [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2 — passives Lauschen)
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
 - [ ] Background Audio Service (TTS auch bei minimierter App)
 
-### TTS / Audio
-- [ ] Audio-Normalisierung (Lautstaerke zwischen Saetzen/Chunks angleichen)
-- [ ] F5-TTS: Streaming-Inferenz testen (nativ statt satzweise) wenn ein passendes Backend kommt
-- [ ] F5-TTS: Optional Deepspeed-Beschleunigung pruefen
-
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
 - [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)

rvs/server.js

@@ -21,6 +21,8 @@ const ALLOWED_TYPES = new Set([
   "xtts_delete_voice",
   "voice_preload", "voice_ready",
   "stt_request", "stt_response",
+  "service_status",
+  "config_request",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }
@@ -53,7 +55,10 @@ function cleanupRooms() {
 
 // ── WebSocket-Server starten ────────────────────────────────────────
 
-const wss = new WebSocketServer({ port: PORT });
+// maxPayload 50MB: TTS-Streaming + Voice-Upload (WAV als base64) +
+// audio_pcm Chunks koennen die ws-Library Default 1MB ueberschreiten.
+// Default-Limit war der Killer fuer die voice_upload Pipeline.
+const wss = new WebSocketServer({ port: PORT, maxPayload: 50 * 1024 * 1024 });
 
 wss.on("listening", () => {
   log(`RVS läuft auf Port ${PORT} | Max Sessions: ${MAX_SESSIONS}`);

xtts/.gitignore

@@ -1,5 +1,5 @@
-# HuggingFace Model-Cache (geteilt zwischen f5tts + whisper bridge,
-# wird via Bind-Mount in die Container reingehaengt)
+# HuggingFace Model-Cache (Whisper + F5-TTS, geteilt zwischen den
+# beiden Bridges via Bind-Mount, kann mehrere GB werden)
 hf-cache/
 
 # Voice-Samples (lokal, gehoert nicht ins Repo)

xtts/docker-compose.yml

@@ -33,8 +33,8 @@ services:
       - ./voices:/voices                         # WAV + TXT Referenz
       - ./hf-cache:/root/.cache/huggingface      # HF-Cache als Bind-Mount.
                                                  # Direkt sichtbar im xtts/hf-cache/,
-                                                 # einfach zu loeschen, kein Docker-
-                                                 # Desktop .vhdx Bloat.
+                                                 # einfach manuell zu loeschen, kein
+                                                 # Docker-Desktop .vhdx Bloat.
                                                  # Wird mit whisper-bridge geteilt.
     environment:
       # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
@@ -78,5 +78,8 @@ services:
       - WHISPER_COMPUTE_TYPE=${WHISPER_COMPUTE_TYPE:-float16}
       - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-de}
     volumes:
-      - ./hf-cache:/root/.cache/huggingface      # gleicher Cache wie f5tts-bridge
+      - ./hf-cache:/root/.cache/huggingface      # gleicher Cache wie f5tts-bridge —
+                                                 # ein Modell muss nur einmal pro
+                                                 # Maschine geladen werden, kein
+                                                 # Re-Download bei Container-Restart.
     restart: unless-stopped

xtts/f5tts/bridge.py

@@ -73,6 +73,12 @@ VOICES_DIR = Path(os.getenv("VOICES_DIR", "/voices"))
 
 PCM_CHUNK_BYTES = 8192   # ~170ms @ 24kHz mono s16
 TARGET_SR = 24000        # F5-TTS native
+# F5-TTS hat ein 12s Hard-Limit fuer Referenz-Audio. Laengere WAVs werden
+# vom Modell stumm abgeschnitten — aber unser ref_text bleibt lang und passt
+# dann nicht mehr zum gekuerzten Audio (Quali leidet, warmup-Render ist
+# unnoetig lange). Wir clippen explizit auf 10s + re-transkribieren den Text
+# damit beide synchron bleiben.
+REF_MAX_SECONDS = 10.0
 
 # Wird in einer Uebergangsphase als "ungueltige Referenz" erkannt (alte voices,
 # die hochgeladen wurden bevor die whisper-bridge online war). Bei Erkennung
@@ -93,6 +99,33 @@ def _get_f5tts_cls():
     return _F5TTS_cls
 
 
+def _resolve_hf_path(p: str) -> str:
+    """Wenn p mit 'hf://' anfaengt → aus HuggingFace Hub runterladen,
+    lokalen Pfad zurueckgeben. Sonst unveraendert.
+
+    Format: hf://user/repo/path/to/file.ext
+    Beispiel: hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors
+    """
+    if not p or not p.startswith("hf://"):
+        return p
+    try:
+        from huggingface_hub import hf_hub_download
+        rest = p[5:]
+        parts = rest.split("/", 2)
+        if len(parts) < 3:
+            logger.warning("Ungueltiges hf:// Format: %s (erwarte hf://user/repo/path)", p)
+            return p
+        repo_id = f"{parts[0]}/{parts[1]}"
+        filename = parts[2]
+        logger.info("HF-Download: %s aus %s", filename, repo_id)
+        local = hf_hub_download(repo_id=repo_id, filename=filename)
+        logger.info("HF-Download fertig: %s", local)
+        return local
+    except Exception as e:
+        logger.exception("HF-Download fehlgeschlagen fuer %s: %s", p, e)
+        return p
+
+
 class F5Runner:
     """Haelt das F5-TTS-Modell. Synthese laeuft im Executor (blocking).
 
@@ -110,20 +143,28 @@ class F5Runner:
         self.vocab_file: str = DEFAULT_F5TTS_VOCAB_FILE
         self.cfg_strength: float = DEFAULT_F5TTS_CFG_STRENGTH
         self.nfe_step: int = DEFAULT_F5TTS_NFE_STEP
+        # Last load-time fuer service_status Broadcast
+        self.last_load_seconds: float = 0.0
+        self._load_started_at: float = 0.0
 
     def _load_blocking(self) -> None:
         cls = _get_f5tts_cls()
+        ckpt_resolved = _resolve_hf_path(self.ckpt_file) if self.ckpt_file else ""
+        vocab_resolved = _resolve_hf_path(self.vocab_file) if self.vocab_file else ""
         logger.info("Lade F5-TTS '%s' (device=%s, ckpt=%s)...",
-                    self.model_id, F5TTS_DEVICE, self.ckpt_file or "default")
-        t0 = time.time()
+                    self.model_id, F5TTS_DEVICE, ckpt_resolved or "default")
+        self._load_started_at = time.time()
         kwargs = {"model": self.model_id, "device": F5TTS_DEVICE}
-        if self.ckpt_file:
-            kwargs["ckpt_file"] = self.ckpt_file
-        if self.vocab_file:
-            kwargs["vocab_file"] = self.vocab_file
+        if ckpt_resolved:
+            kwargs["ckpt_file"] = ckpt_resolved
+        if vocab_resolved:
+            kwargs["vocab_file"] = vocab_resolved
         self.model = cls(**kwargs)
+        elapsed = time.time() - self._load_started_at
         logger.info("F5-TTS geladen in %.1fs (cfg_strength=%.1f, nfe=%d)",
-                    time.time() - t0, self.cfg_strength, self.nfe_step)
+                    elapsed, self.cfg_strength, self.nfe_step)
+        # Wird von outside (run_loop) gelesen um service_status auf 'ready' zu setzen
+        self.last_load_seconds = elapsed
 
     async def ensure_loaded(self) -> None:
         async with self._lock:
@@ -134,10 +175,31 @@ class F5Runner:
 
     async def update_config(self, payload: dict) -> None:
         """Liest f5tts*-Felder aus einem config-Broadcast.
-        Bei Modell-relevantem Wechsel wird neu geladen."""
-        new_model = (payload.get("f5ttsModel") or "").strip() or self.model_id
-        new_ckpt = payload.get("f5ttsCkptFile", self.ckpt_file) or ""
-        new_vocab = payload.get("f5ttsVocabFile", self.vocab_file) or ""
+        Bei Modell-relevantem Wechsel wird neu geladen.
+
+        Semantik:
+          - key fehlt in payload     → aktuellen Wert behalten
+          - key da, nicht-leerer str → diesen Wert nehmen
+          - key da, leerer string    → RESET auf Hard-Default (User hat Feld
+                                       in Diagnostic geleert und Apply geklickt)
+        """
+        if "f5ttsModel" in payload:
+            v = (payload.get("f5ttsModel") or "").strip()
+            new_model = v if v else DEFAULT_F5TTS_MODEL
+        else:
+            new_model = self.model_id
+
+        if "f5ttsCkptFile" in payload:
+            v = payload.get("f5ttsCkptFile") or ""
+            new_ckpt = v.strip() if isinstance(v, str) else ""
+        else:
+            new_ckpt = self.ckpt_file
+
+        if "f5ttsVocabFile" in payload:
+            v = payload.get("f5ttsVocabFile") or ""
+            new_vocab = v.strip() if isinstance(v, str) else ""
+        else:
+            new_vocab = self.vocab_file
         try:
             new_cfg = float(payload.get("f5ttsCfgStrength", self.cfg_strength))
         except (TypeError, ValueError):
@@ -175,7 +237,8 @@ class F5Runner:
         else:
             logger.info("F5-TTS Live-Config: cfg_strength=%.2f nfe=%d", new_cfg, new_nfe)
 
-    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
+    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str,
+                        speed: float = 1.0) -> tuple[np.ndarray, int]:
         wav, sr, _ = self.model.infer(
             ref_file=ref_wav,
             ref_text=ref_text,
@@ -184,6 +247,7 @@ class F5Runner:
             seed=-1,
             cfg_strength=self.cfg_strength,
             nfe_step=self.nfe_step,
+            speed=speed,
         )
         # F5-TTS gibt float32 1D-Array — auf 24kHz sample-rate standard
         if not isinstance(wav, np.ndarray):
@@ -192,10 +256,11 @@ class F5Runner:
             wav = wav.squeeze()
         return wav.astype(np.float32), int(sr)
 
-    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
+    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str,
+                         speed: float = 1.0) -> tuple[np.ndarray, int]:
         await self.ensure_loaded()
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text)
+        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text, speed)
 
 
 # ── Helpers ─────────────────────────────────────────────────
@@ -227,7 +292,15 @@ def split_sentences(text: str, max_len: int = 350) -> list[str]:
 
 
 def float_to_pcm16(wav: np.ndarray) -> bytes:
-    """Float32 (-1..+1) → int16 little-endian bytes."""
+    """Float32 (-1..+1) → int16 little-endian bytes.
+
+    F5-TTS generiert gelegentlich NaN/Inf bei Instabilitaeten — ohne sanitize
+    waere der Cast zu int16 undefiniert (RuntimeWarning + kaputter Sound).
+    """
+    nan_count = int(np.isnan(wav).sum() + np.isinf(wav).sum())
+    if nan_count > 0:
+        logger.warning("F5-TTS Output enthaelt %d NaN/Inf samples — ersetze mit 0", nan_count)
+        wav = np.nan_to_num(wav, nan=0.0, posinf=1.0, neginf=-1.0)
     wav = np.clip(wav, -1.0, 1.0)
     pcm = (wav * 32767.0).astype(np.int16)
     return pcm.tobytes()
@@ -242,32 +315,51 @@ def voice_paths(name: str) -> tuple[Path, Path]:
     return VOICES_DIR / f"{safe}.wav", VOICES_DIR / f"{safe}.txt"
 
 
-def ensure_24k_mono_wav(src_wav: Path) -> Path:
-    """F5-TTS moechte 24kHz mono als Referenz — ffmpeg konvertiert inplace.
+def normalize_ref_wav(src_wav: Path, max_seconds: float = REF_MAX_SECONDS) -> tuple[Path, bool]:
+    """Bringt die Referenz-WAV in F5-TTS-freundliche Form:
 
-    Wenn das File schon passt, wird nichts geaendert. Sonst wird es
-    reingeschrieben (Original wird ueberschrieben).
+      * 24kHz mono
+      * max max_seconds Dauer
+      * Stille am Anfang + Ende abgeschnitten (silenceremove-Filter)
+      * Lautheit auf -16 LUFS normalisiert (loudnorm-Filter) damit
+        das Modell konsistente Amplituden sieht
+
+    F5-TTS reagiert empfindlich auf leise / verrauschte / zerhackte
+    Referenzen. Konsistente, saubere Input-Lautheit hilft der Quali.
+
+    Returns:
+        (path, was_modified) — was_modified=True wenn die Datei wirklich
+        geaendert wurde (Caller sollte dann den passenden .txt invalidieren).
     """
-    try:
-        info = sf.info(str(src_wav))
-        if info.samplerate == TARGET_SR and info.channels == 1:
-            return src_wav
-    except Exception:
-        pass
     tmp_out = src_wav.with_suffix(".conv.wav")
+    # silenceremove am Anfang: bis -50dB gesprochen wird
+    # silenceremove am Ende: ueber -50dB rein, dann 0.5s stille als Cutoff
+    # loudnorm: EBU R128, Ziel -16 LUFS
+    af = ("silenceremove=start_periods=1:start_duration=0.05:start_threshold=-50dB,"
+          "silenceremove=stop_periods=1:stop_duration=0.5:stop_threshold=-50dB,"
+          "loudnorm=I=-16:TP=-1.5:LRA=11")
     cmd = ["ffmpeg", "-y", "-i", str(src_wav),
-           "-ar", str(TARGET_SR), "-ac", "1", "-f", "wav", str(tmp_out)]
+           "-af", af,
+           "-ar", str(TARGET_SR), "-ac", "1",
+           "-t", str(max_seconds),
+           "-f", "wav", str(tmp_out)]
     r = subprocess.run(cmd, capture_output=True, timeout=30)
     if r.returncode != 0:
-        logger.warning("ffmpeg-Konvertierung von %s fehlgeschlagen: %s",
-                       src_wav, r.stderr.decode(errors="replace")[:200])
+        logger.warning("ffmpeg-Normalisierung von %s fehlgeschlagen: %s",
+                       src_wav, r.stderr.decode(errors="replace")[:300])
         try:
             tmp_out.unlink()
         except OSError:
             pass
-        return src_wav
+        return src_wav, False
     os.replace(tmp_out, src_wav)
-    return src_wav
+    try:
+        info = sf.info(str(src_wav))
+        logger.info("Referenz-WAV normalisiert: %s (%.1fs, %dHz mono, -16 LUFS, silence getrimmt)",
+                    src_wav.name, info.duration, info.samplerate)
+    except Exception:
+        logger.info("Referenz-WAV normalisiert: %s", src_wav.name)
+    return src_wav, True
 
 
 async def _send(ws, mtype: str, payload: dict) -> None:
@@ -306,7 +398,10 @@ async def request_transcription(ws, wav_path: Path, language: str = "de") -> Opt
             "requestId": request_id,
             "audio": audio_b64,
             "mimeType": "audio/wav",
-            "model": "small",  # klein reicht fuer Voice-Referenz
+            # KEIN hardcoded model — whisper-bridge nimmt das bereits
+            # geladene. Sonst wuerde hier ein Swap auf 'small' passieren und
+            # danach muesste das in Diagnostic konfigurierte Modell (z.B.
+            # large-v3) wieder geladen werden → doppelter Download.
             "language": language,
         })
         return await asyncio.wait_for(fut, timeout=_STT_TIMEOUT_S)
@@ -329,9 +424,9 @@ _tts_queue: asyncio.Queue[tuple] = asyncio.Queue()
 async def _tts_worker(ws, runner: F5Runner) -> None:
     """Serialisiert Synthesen — GPU kann sonst OOM gehen."""
     while True:
-        text, voice, request_id, message_id, language = await _tts_queue.get()
+        text, voice, request_id, message_id, language, speed = await _tts_queue.get()
         try:
-            await _do_tts(ws, runner, text, voice, request_id, message_id, language)
+            await _do_tts(ws, runner, text, voice, request_id, message_id, language, speed)
         except Exception:
             logger.exception("TTS-Worker Fehler")
         finally:
@@ -339,10 +434,26 @@ async def _tts_worker(ws, runner: F5Runner) -> None:
 
 
 async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
-                  request_id: str, message_id: str, language: str) -> None:
+                  request_id: str, message_id: str, language: str,
+                  speed: float = 1.0) -> None:
     t0 = time.time()
     ref_wav_path, ref_txt_path = voice_paths(voice) if voice else (None, None)
 
+    # WAV zu lang? F5-TTS limitiert intern auf 12s, dann passt der txt nicht
+    # mehr zum Audio. Wir clippen explizit auf 10s und invalidieren den txt,
+    # damit er on-the-fly passend zum gekuerzten Audio neu transkribiert wird.
+    if voice and ref_wav_path and ref_wav_path.exists():
+        try:
+            info = sf.info(str(ref_wav_path))
+            if info.duration > REF_MAX_SECONDS + 0.5:
+                logger.info("Voice '%s' WAV ist %.1fs (>%.0fs) → clippen + txt neu",
+                            voice, info.duration, REF_MAX_SECONDS)
+                _, modified = normalize_ref_wav(ref_wav_path)
+                if modified and ref_txt_path and ref_txt_path.exists():
+                    ref_txt_path.unlink()
+        except Exception as e:
+            logger.warning("Konnte WAV-Dauer nicht pruefen: %s", e)
+
     # Legacy-Platzhalter erkennen → behandeln als "kein txt" und neu transkribieren
     if voice and ref_txt_path and ref_txt_path.exists():
         try:
@@ -402,7 +513,7 @@ async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
     pcm_sr = TARGET_SR
     for i, sent in enumerate(sentences):
         try:
-            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text)
+            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text, speed)
             pcm_sr = sr
             pcm_bytes = float_to_pcm16(wav)
             # Erste PCM-Chunk des allerersten Satzes bekommt Fade-In (maskiert
@@ -485,8 +596,9 @@ async def handle_voice_upload(ws, payload: dict) -> None:
         size_kb = wav_path.stat().st_size / 1024
         logger.info("Voice WAV gespeichert: %s (%.0fKB)", wav_path, size_kb)
 
-        # Auf 24kHz mono normalisieren (falls App in anderem Format liefert)
-        ensure_24k_mono_wav(wav_path)
+        # Auf 24kHz mono clippen auf 10s (F5-TTS Hard-Limit ist 12s,
+        # kuerzer = schnellerer Warmup + Text+Audio bleiben aligned)
+        normalize_ref_wav(wav_path)
 
         # Transkription ueber whisper-bridge anfragen
         logger.info("Transkribiere '%s' via whisper-bridge...", name)
@@ -580,10 +692,15 @@ async def handle_voice_preload(ws, payload: dict, runner: F5Runner) -> None:
 
 # ── Haupt-Loop ──────────────────────────────────────────────
 
-async def run_loop(runner: F5Runner) -> None:
-    # Preload im Hintergrund starten damit der Startup nicht blockiert
-    asyncio.create_task(runner.ensure_loaded())
+async def _broadcast_status(ws, state: str, **extra) -> None:
+    """Sendet service_status fuer das F5-TTS Modul.
+    state: 'loading' | 'ready' | 'error'."""
+    payload = {"service": "f5tts", "state": state}
+    payload.update(extra)
+    await _send(ws, "service_status", payload)
 
+
+async def run_loop(runner: F5Runner) -> None:
     use_tls = RVS_TLS
     retry_s = 2
     tls_fallback_tried = False
@@ -601,6 +718,33 @@ async def run_loop(runner: F5Runner) -> None:
                 retry_s = 2
                 tls_fallback_tried = False
 
+                # Status-Broadcast: erst loading, dann ready nach erfolgreichem Load.
+                # Plus: config_request damit wir die persistierte Diagnostic-Config
+                # bekommen, falls aria-bridge ihre nicht von alleine sendet.
+                async def _load_with_status():
+                    try:
+                        if runner.model is not None:
+                            logger.info("Initial: broadcaste ready (Modell schon im RAM: %s)", runner.model_id)
+                            await _broadcast_status(ws, "ready",
+                                                    model=runner.model_id,
+                                                    loadSeconds=runner.last_load_seconds)
+                        else:
+                            logger.info("Initial: broadcaste loading + lade Modell '%s'", runner.model_id)
+                            await _broadcast_status(ws, "loading", model=runner.model_id)
+                            await runner.ensure_loaded()
+                            await _broadcast_status(ws, "ready",
+                                                    model=runner.model_id,
+                                                    loadSeconds=runner.last_load_seconds)
+                        logger.info("Initial: sende config_request an aria-bridge")
+                        await _send(ws, "config_request", {"service": "f5tts"})
+                    except Exception as e:
+                        logger.exception("Initial-Load crashed: %s", e)
+                        try:
+                            await _broadcast_status(ws, "error", error=str(e)[:200])
+                        except Exception:
+                            pass
+                asyncio.create_task(_load_with_status())
+
                 # TTS-Worker fuer diese Verbindung starten
                 worker = asyncio.create_task(_tts_worker(ws, runner))
 
@@ -614,12 +758,19 @@ async def run_loop(runner: F5Runner) -> None:
                         payload = msg.get("payload", {}) or {}
 
                         if mtype == "xtts_request":
+                            try:
+                                speed = float(payload.get("speed") or 1.0)
+                            except (TypeError, ValueError):
+                                speed = 1.0
+                            if not (0.1 <= speed <= 5.0):
+                                speed = 1.0
                             await _tts_queue.put((
                                 payload.get("text", ""),
                                 payload.get("voice", "") or "",
                                 payload.get("requestId", ""),
                                 payload.get("messageId", ""),
                                 payload.get("language", "de"),
+                                speed,
                             ))
                         elif mtype == "voice_upload":
                             asyncio.create_task(handle_voice_upload(ws, payload))
@@ -640,7 +791,26 @@ async def run_loop(runner: F5Runner) -> None:
                                     fut.set_result(payload.get("text") or "")
                         elif mtype == "config":
                             # F5-TTS-Settings aktualisieren (Modell, cfg_strength, nfe)
-                            asyncio.create_task(runner.update_config(payload))
+                            async def _update_with_status(p):
+                                # Schaut ob ein Modell-Wechsel ansteht — falls ja:
+                                # erst loading-Status, dann update, dann ready.
+                                old_model = (runner.model_id, runner.ckpt_file, runner.vocab_file)
+                                new_model_id = (p.get("f5ttsModel") or runner.model_id,
+                                                p.get("f5ttsCkptFile", runner.ckpt_file) or "",
+                                                p.get("f5ttsVocabFile", runner.vocab_file) or "")
+                                will_reload = old_model != new_model_id
+                                if will_reload:
+                                    await _broadcast_status(ws, "loading", model=new_model_id[0])
+                                try:
+                                    await runner.update_config(p)
+                                    if will_reload:
+                                        await _broadcast_status(ws, "ready",
+                                                                model=runner.model_id,
+                                                                loadSeconds=runner.last_load_seconds)
+                                except Exception as e:
+                                    if will_reload:
+                                        await _broadcast_status(ws, "error", error=str(e)[:200])
+                            asyncio.create_task(_update_with_status(payload))
                             # Voice-Preload bei Wechsel
                             v = (payload.get("xttsVoice") or "").strip()
                             if v and v != _last_diag_voice:

xtts/whisper/bridge.py

@@ -143,7 +143,11 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
     request_id = payload.get("requestId", "")
     audio_b64 = payload.get("audio", "")
     mime_type = payload.get("mimeType", "audio/mp4")
-    model = payload.get("model") or WHISPER_MODEL
+    # Modell-Auswahl:
+    #   payload.model gesetzt  → nimm das (aria-bridge sendet's basierend auf Config)
+    #   sonst + Modell geladen → behalt das aktuelle (kein sinnloser Swap)
+    #   sonst                  → fallback auf ENV-Default
+    model = payload.get("model") or (runner.model_size if runner.model is not None else WHISPER_MODEL)
     language = payload.get("language") or WHISPER_LANGUAGE
 
     if not audio_b64:
@@ -152,8 +156,17 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
 
     try:
         t_load = time.time()
+        # Falls Modell noch nicht geladen (Race-Condition: stt_request vor config)
+        # → Status-Broadcast loading→ready damit der App-Banner aufpoppt
+        needs_load = runner.model is None or runner.model_size != model
+        if needs_load:
+            await _broadcast_status(ws, "loading", model=model)
         await runner.ensure_loaded(model)
         load_ms = int((time.time() - t_load) * 1000)
+        if needs_load:
+            await _broadcast_status(ws, "ready",
+                                    model=runner.model_size,
+                                    loadSeconds=load_ms / 1000.0)
 
         audio = ffmpeg_to_float32(audio_b64, mime_type)
         if audio.size == 0:
@@ -184,13 +197,15 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
         })
 
 
-async def run_loop(runner: WhisperRunner) -> None:
-    # Modell vorab laden damit erste Anfrage flott ist
-    try:
-        await runner.ensure_loaded(WHISPER_MODEL)
-    except Exception as e:
-        logger.error("Preload fehlgeschlagen: %s — Fortsetzung, wird bei erstem Request nachgeladen", e)
+async def _broadcast_status(ws, state: str, **extra) -> None:
+    """Sendet service_status fuer das Whisper-Modul.
+    state: 'loading' | 'ready' | 'error'."""
+    payload = {"service": "whisper", "state": state}
+    payload.update(extra)
+    await _send(ws, "service_status", payload)
 
+
+async def run_loop(runner: WhisperRunner) -> None:
     use_tls = RVS_TLS
     retry_s = 2
     tls_fallback_tried = False
@@ -201,10 +216,35 @@ async def run_loop(runner: WhisperRunner) -> None:
         masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url
         try:
             logger.info("Verbinde zu RVS: %s", masked)
-            async with websockets.connect(url, ping_interval=20, ping_timeout=10) as ws:
+            # max_size 50MB damit grosse stt_request (Voice-Cloning-WAVs als
+            # base64 koennen mehrere MB werden) nicht das Frame-Limit sprengen
+            # und die Verbindung mit 1009 'message too big' killen.
+            async with websockets.connect(url, ping_interval=20, ping_timeout=10, max_size=50 * 1024 * 1024) as ws:
                 logger.info("RVS verbunden")
                 retry_s = 2
                 tls_fallback_tried = False
+
+                # Initialer Status-Broadcast — uebertont alten "ready"-State
+                # im App/Diagnostic Banner (sonst denkt der User noch alles ist
+                # gut von vorher). Wenn Modell schon geladen → ready, sonst
+                # loading mit aktuellem (Default-)Namen.
+                # Plus: config_request an aria-bridge — wir wissen nicht ob
+                # sie auch grad reconnected hat oder schon laenger online ist.
+                async def _initial_handshake():
+                    try:
+                        if runner.model is not None:
+                            logger.info("Initial: broadcaste ready (Modell schon im RAM: %s)", runner.model_size)
+                            await _broadcast_status(ws, "ready", model=runner.model_size)
+                        else:
+                            init_model = runner.model_size or WHISPER_MODEL
+                            logger.info("Initial: broadcaste loading (model=%s)", init_model)
+                            await _broadcast_status(ws, "loading", model=init_model)
+                        logger.info("Initial: sende config_request an aria-bridge")
+                        await _send(ws, "config_request", {"service": "whisper"})
+                    except Exception as e:
+                        logger.exception("Initial-Handshake crashed: %s", e)
+                asyncio.create_task(_initial_handshake())
+
                 async for raw in ws:
                     try:
                         msg = json.loads(raw)
@@ -220,10 +260,25 @@ async def run_loop(runner: WhisperRunner) -> None:
                                     req_id[:8] if req_id != "?" else "?", audio_len // 1365)
                         asyncio.create_task(handle_stt_request(ws, payload, runner))
                     elif mtype == "config":
-                        new_model = payload.get("whisperModel")
-                        if new_model and new_model != runner.model_size:
-                            logger.info("Config-Broadcast: Whisper-Modell → %s", new_model)
-                            asyncio.create_task(runner.ensure_loaded(new_model))
+                        new_model = payload.get("whisperModel") or WHISPER_MODEL
+                        # Laden wenn (a) noch nix geladen, oder (b) Modell wechselt
+                        needs_load = (runner.model is None) or (new_model != runner.model_size)
+                        if needs_load:
+                            logger.info("Config-Broadcast: Whisper-Modell -> %s%s",
+                                        new_model,
+                                        " (initial)" if runner.model is None else " (Wechsel)")
+                            async def _swap_with_status(target):
+                                await _broadcast_status(ws, "loading", model=target)
+                                try:
+                                    t0 = time.time()
+                                    await runner.ensure_loaded(target)
+                                    elapsed = time.time() - t0
+                                    await _broadcast_status(ws, "ready",
+                                                            model=runner.model_size,
+                                                            loadSeconds=elapsed)
+                                except Exception as e:
+                                    await _broadcast_status(ws, "error", error=str(e)[:200])
+                            asyncio.create_task(_swap_with_status(new_model))
                     else:
                         # Alle anderen Nachrichten debug-loggen — hilft beim Diagnostizieren,
                         # ob stt_request ueberhaupt durch den RVS kommt