fix: stream_chunk_size auf 250 erhoeht — weniger Render-Artefakte

XTTS daswer123 erzeugt an Chunk-Grenzen oft Glitches in den Worten die ueber die Grenze gehen. 100 → 250 = weniger Grenzen pro Satz = sauberere Sprachausgabe. Erste-Audio-Latenz steigt um ein paar Sekunden, was aber OK ist seit die App Pre-Roll gepuffert ist. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
release: bump version to 0.0.4.7
2026-04-22 18:56:00 +02:00 · 2026-04-22 18:46:25 +02:00 · 2026-04-22 18:44:38 +02:00 · 2026-04-22 18:32:31 +02:00 · 2026-04-22 18:31:12 +02:00 · 2026-04-22 18:18:20 +02:00
30 changed files with 730 additions and 2679 deletions
@@ -15,7 +15,7 @@ ARIA_AUTH_TOKEN=change-me-to-a-long-random-string
 # App, Bridge, Diagnostic und XTTS-Bridge verbinden sich hierueber.
 # Alle muessen den gleichen Host, Port und Token nutzen.

-# Hostname des RVS-Servers (z.B. rvs.example.de oder example.com)
+# Hostname des RVS-Servers (z.B. rvs.example.de oder mobil.hacker-net.de)
 RVS_HOST=rvs.example.de

 # Port auf dem der RVS laeuft (muss mit rvs/docker-compose.yml uebereinstimmen)
@@ -34,21 +34,13 @@ ARIA hat zwei Rollen:
 └───────────┬───────────────────────────┬─────────────────┘
            │ WebSocket Tunnel          │ WebSocket Tunnel
            ▼                           ▼
-┌─────────────────────────────────┐
-│  Gamebox (Windows + WSL2)        │
-│  RTX 3060, Docker Desktop       │
-│  ┌──────────────────────────┐   │
-│  │ aria-f5tts-bridge        │   │
-│  │  F5-TTS Voice Cloning    │   │
-│  │  PCM-Streaming an die App │   │
-│  ├──────────────────────────┤   │
-│  │ aria-whisper-bridge      │   │
-│  │  Faster-Whisper CUDA     │   │
-│  │  STT in fast-Echtzeit    │   │
-│  └──────────────────────────┘   │
-│  Beide teilen ./voices Volume    │
-│  xtts/docker-compose.yml        │
-└─────────────────────────────────┘
+┌───────────────────────────┐
+│  Gaming-PC (optional)      │
+│  RTX 3060, Docker+WSL2    │
+│  XTTS v2 (natuerliche     │
+│  Stimmen, Voice Cloning)   │
+│  xtts/docker-compose.yml  │
+└───────────────────────────┘
 ┌─────────────────────────────────────────────────────────┐
 │     ARIA-VM (Proxmox, Debian 13) — ARIAs Wohnung        │
 │     Basissystem + Docker. Rest richtet ARIA selbst ein.  │
@@ -65,10 +57,8 @@ ARIA hat zwei Rollen:
 │  │             Liest BOOTSTRAP.md + AGENT.md         │    │
 │  │                                                   │    │
 │  │  [bridge]   ARIA Voice Bridge Container           │    │
-│  │             Wake-Word (lokales Mikro auf VM)       │    │
-│  │             STT primaer remote (Gamebox-Whisper)   │    │
-│  │             Fallback: lokales faster-whisper (CPU) │    │
-│  │             TTS via F5-TTS auf Gamebox             │    │
+│  │             Whisper STT · Wake-Word                │    │
+│  │             TTS remote via XTTS v2 auf Gaming-PC  │    │
 │  │             Bruecke: App <> RVS <> Bridge <> ARIA │    │
 │  │                                                   │    │
 │  │  [diagnostic] Selbstcheck-UI + Einstellungen      │    │
@@ -89,12 +79,9 @@ ARIA hat zwei Rollen:
 |-----|----|-----|
 | RVS | Rechenzentrum | `cd rvs && docker compose up -d` |
 | ARIA Core | Debian 13 VM | `docker compose up -d && ./aria-setup.sh` |
-| Gamebox-Stack (F5-TTS + Whisper) | Gamebox (GPU) | `cd xtts && docker compose up -d` |
+| XTTS v2 (optional) | Gaming-PC (GPU) | `cd xtts && docker compose up -d` |
 | Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |

-> Der Gamebox-Stack ist optional: ohne ihn faellt STT auf lokales Whisper (CPU,
-> langsamer) zurueck; TTS bleibt aus (ARIA antwortet dann nur als Text).
-
 ---

 ## Installation — Schritt fuer Schritt
@@ -160,12 +147,11 @@ in den Proxy gemountet. Die Credentials ueberleben Container-Restarts.

 ```bash
 cp aria-data/config/aria.env.example aria-data/config/aria.env
-# Bei Bedarf anpassen (Whisper-Modell als Fallback, Sprache, Wake-Word)
+# Bei Bedarf anpassen (Whisper-Modell, Sprache, Wake-Word)
 ```

-STT laeuft primaer auf der Gamebox (faster-whisper auf GPU), TTS ausschliesslich
-ueber F5-TTS auf der Gamebox — siehe Abschnitt "Gamebox-Stack — F5-TTS + Whisper"
-weiter unten.
+TTS laeuft ausschliesslich ueber XTTS v2 auf dem Gaming-PC — siehe Abschnitt
+"XTTS v2 — High-Quality TTS" weiter unten.

 ### 5. RVS-Token generieren & Container starten

@@ -298,34 +284,25 @@ braucht ARIA mehrere API-Roundtrips.

 ## Voice Bridge

-Die Bridge verbindet die Android App mit ARIA und orchestriert die GPU-Services
-auf der Gamebox.
+Die Bridge verbindet die Android App mit ARIA und bietet lokale Sprachverarbeitung.

 **Nachrichtenfluss:**
 ```
 Text:   App → RVS → Bridge → chat.send → aria-core
-Audio:  App → RVS → Bridge → stt_request (RVS) → whisper-bridge (Gamebox)
-                          → stt_response → Bridge → chat.send → aria-core
-        Fallback bei Timeout: lokales faster-whisper (CPU)
+Audio:  App → RVS → Bridge → FFmpeg → Whisper STT → chat.send → aria-core
 Datei:  App → RVS → Bridge → /shared/uploads/ → chat.send (mit Pfad) → aria-core

 aria-core → Antwort → Gateway → Diagnostic → RVS → App
-                              → Bridge → xtts_request (RVS) → f5tts-bridge
-                              → audio_pcm Stream → RVS → App AudioTrack
+                              → Bridge → XTTS (PCM-Stream) → RVS → App AudioTrack
 ```

 ### Features

- **STT primaer remote**: aria-bridge sendet `stt_request` an die Gamebox-Whisper
-  (faster-whisper CUDA, fast Echtzeit). 45s Timeout, dann Fallback auf lokales
-  CPU-Whisper. Modell-Wahl in Diagnostic, Hot-Swap via config-Broadcast.
- **TTS via F5-TTS**: aria-f5tts-bridge auf der Gamebox. Voice Cloning mit
-  Referenz-Audio + automatisch transkribiertem Referenz-Text.
- **Text-Cleanup**: `<voice>...</voice>` Tag bevorzugt; Markdown, Code,
-  Einheiten und URLs werden TTS-gerecht aufbereitet. Dezimalzahlen werden
-  ausgeschrieben (`0,1` → "null komma eins"). Acronyme bis 5 Buchstaben werden
-  buchstabiert (`USB` → "U S B", `XTTS` → "X T T S").
- **Wake-Word**: openwakeword (lokales Mikrofon auf der VM, optional)
+- **STT**: faster-whisper (lokal, offline, 16kHz mono)
+- **TTS**: XTTS v2 (remote auf Gaming-PC, GPU, Voice Cloning) — Streaming ueber PCM-Chunks
+- **Text-Cleanup**: `<voice>...</voice>` Tag bevorzugt, Markdown/Code/Einheiten/URLs werden TTS-gerecht aufbereitet
+- **Wake-Word**: openwakeword (lokales Mikrofon auf der VM)
+- **App-Audio**: Base64 Audio von App → FFmpeg → Whisper STT → Text an aria-core
 - **Modi**: Normal, Nicht stoeren, Fluestern, Hangar, Gaming

 ### Betriebsmodi
@@ -347,16 +324,14 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit aria-core.
 ### Features

 - **Status-Karten**: Gateway (Handshake), RVS (TLS-Fallback), Proxy (Auth)
- **Disk-Voll Banner**: Rotes Overlay wenn die VM-Disk knapp wird, mit copy-baren Cleanup-Befehlen (safe + aggressiv)
 - **Chat-Test**: Nachrichten direkt an ARIA senden (Gateway oder via RVS), Vollbild-Modus
 - **"ARIA denkt..." Indikator**: Zeigt live was ARIA gerade tut (Denken, Tool, Schreiben)
 - **Abbrechen-Button**: Stoppt laufende Anfragen + doctor --fix
 - **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen, als Markdown exportieren (⬇ Button)
 - **Chat-History**: Wird beim Laden und Session-Wechsel angezeigt (read-only aus JSONL)
 - **TTS-Diagnose Tab**: Stimmen testen, Status pruefen, Fehler anzeigen
- **Einstellungen**: TTS aktiv-Toggle, F5-TTS-Voice (gecloned), Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload auf der Gamebox)
- **Voice-Status**: Beim Wechsel der globalen Stimme zeigt ein Status-Text "Lade…" → "bereit (X.Ys)" — getriggert ueber `voice_preload`/`voice_ready`
- **Voice Cloning**: Audio-Samples hochladen, Referenz-Text wird automatisch via Whisper transkribiert
+- **Einstellungen**: TTS aktiv-Toggle, XTTS-Voice (gecloned), Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload)
+- **XTTS Voice Cloning**: Audio-Samples hochladen, eigene Stimme erstellen
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
 - **Core Terminal**: Shell in aria-core (openclaw CLI)
 - **Container-Logs**: Echtzeit-Logs aller Container (gefiltert nach Tab + Pipeline)
@@ -379,21 +354,18 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`

 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
- **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
- **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
- **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
- **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
+- **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her, ohne Buttons druecken
+- **VAD (Voice Activity Detection)**: Erkennt 1.8s Stille und stoppt automatisch
+- **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt (kein Rauschen an Whisper)
+- **STT (Speech-to-Text)**: Audio wird als 16kHz mono aufgenommen und in der Bridge per Whisper transkribiert, transkribierter Text erscheint im Chat
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
- **TTS-Wiedergabe**: F5-TTS PCM-Streaming direkt in AudioTrack mit konfigurierbarem Pre-Roll-Buffer (1.0–6.0s, Default 3.5s) gegen Gaps bei Render-Pausen
- **Audio-Pause**: Andere Apps (Spotify, YouTube etc.) pausieren komplett waehrend ARIA spricht und kommen erst wieder nach echtem Wiedergabe-Ende
- **Lokale Voice-Wahl**: Pro Geraet eigene Stimme moeglich (in Settings). Diagnostic-Wechsel ueberschreibt alle App-Wahlen.
- **Voice-Ready Toast**: Beim Wechsel zeigt die App "Stimme X bereit (X.Ys)" sobald der Preload durch ist
- **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden (aus Cache wenn vorhanden, sonst neu rendern)
+- **TTS-Wiedergabe**: ARIA antwortet per Lautsprecher — XTTS v2 PCM-Streaming direkt in AudioTrack, keine Wait-Gaps
+- **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden
 - **Chat-Suche**: Lupe in der Statusleiste filtert Nachrichten live
 - **Mehrere Anhaenge**: Bilder + Dateien sammeln, Text hinzufuegen, dann zusammen senden
 - **Paste-Support**: Bilder aus Zwischenablage einfuegen (Diagnostic)
 - **Anhaenge**: Bridge speichert in Shared Volume, ARIA kann darauf zugreifen, Re-Download ueber RVS
- **Einstellungen**: TTS-aktiv, F5-TTS-Voice, Pre-Roll-Buffer, Stille-Toleranz, Speicherort, Auto-Download, GPS
+- **Einstellungen**: TTS aktiv, XTTS-Voice, Speicherort, Auto-Download, GPS
 - **Auto-Update**: Prueft beim Start + per Button auf neue Version, Download + Installation ueber RVS (FileProvider)
 - GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing
@@ -568,7 +540,7 @@ cp ARIA-v0.0.3.0.apk ~/ARIA-AGENT/rvs/updates/

 ---

-## Gamebox-Stack — F5-TTS + Whisper (GPU-Services)
+## XTTS v2 — GPU TTS Server (optional)

 Laeuft auf einem separaten Rechner mit NVIDIA GPU (z.B. Gaming-PC mit RTX 3060).
 Verbindet sich ueber RVS mit der ARIA-Infrastruktur — kein VPN noetig, funktioniert
@@ -577,27 +549,22 @@ ueber verschiedene Netze hinweg.
 ### Architektur

 ```
-Gamebox (Windows, RTX 3060, Docker Desktop + WSL2)
-├── aria-f5tts-bridge       F5-TTS Voice Cloning + RVS-Relay
-│                           Hoert auf xtts_request, streamt audio_pcm
-├── aria-whisper-bridge     faster-whisper auf CUDA (float16)
-│                           Hoert auf stt_request, antwortet mit stt_response
-└── ./voices/               Geteilt zwischen beiden:
-                              {name}.wav  — Referenz-Audio (~6-10s)
-                              {name}.txt  — Referenz-Text (auto via Whisper)
+Gaming-PC (Windows, RTX 3060, Docker Desktop + WSL2)
+├── aria-xtts        XTTS v2 GPU Server (Port 8020 intern)
+└── aria-xtts-bridge RVS-Relay (empfaengt Requests, sendet Audio)
+    └── Beide teilen ./voices/ Volume fuer Voice Cloning

         ↕ RVS (Rechenzentrum, WebSocket Relay)

 ARIA-VM
-└── aria-bridge: STT primaer remote (45s Timeout, dann lokaler CPU-Fallback)
-                 TTS via xtts_request → audio_pcm Stream
+└── aria-bridge: tts_engine="xtts" → xtts_request via RVS → wartet auf xtts_response
 ```

 ### Voraussetzungen

 - Docker Desktop mit WSL2 (Windows) oder Docker mit NVIDIA Runtime (Linux)
 - NVIDIA Container Toolkit
- GPU mit mindestens 6GB VRAM (Whisper-large + F5-TTS gemeinsam)
+- GPU mit mindestens 4GB VRAM (6GB+ empfohlen)
 - **Gleicher RVS_TOKEN wie auf der ARIA-VM!**

 ### Setup
@@ -607,45 +574,34 @@ cd xtts
 cp .env.example .env
 # .env mit RVS-Verbindungsdaten fuellen (gleicher Token wie ARIA-VM!)
 docker compose up -d
-# Erster Start laedt die Modelle (Whisper ~1-3GB je nach Groesse, F5-TTS ~1GB)
+# Erster Start laedt ~2GB Model herunter (danach gecacht)
 ```

-Die Modelle werden in den Volumes `f5tts-models` und `whisper-models` gecacht
-und muessen nur einmal geladen werden.
+**Wichtig:** Der XTTS-Server laeuft intern auf Port **8020** (nicht 8000).
+Das Model wird im Volume `xtts-models` gecacht und muss nur einmal geladen werden.

 ### Features

-**F5-TTS (Sprachausgabe):**
- Hochqualitatives Voice Cloning auf Basis von 6-10s Referenz-Audio
- Renderzeit ~0.3x Realtime auf RTX 3060 (RTF ≈ 0.3)
- Satzweises Streaming, fade-in auf erstem Chunk gegen Warmup-Glitches
- Sequentielle Queue gegen GPU-OOM bei parallelen Requests
-
-**Whisper (Spracherkennung):**
- faster-whisper mit CUDA + float16 — fast Echtzeit-Transkription
- Modelle: tiny / base / small / medium / large-v3 (Hot-Swap via Diagnostic)
- Wird zusaetzlich von der f5tts-bridge intern genutzt um den Referenz-Text
-  beim Voice-Upload automatisch zu erzeugen
+- **Natuerliche Stimmen**: Deutlich bessere Qualitaet als TTS der alten Generation
+- **Voice Cloning**: Eigene Stimme mit 6-10s Audio-Sample (~2s Latenz auf RTX 3060)
+- **Streaming**: PCM-Chunks alle ~170ms → App spielt ohne Warten nahtlos
+- **16 Sprachen**: Deutsch, Englisch, Franzoesisch, etc.

 ### TTS-Config

 In der Diagnostic unter Einstellungen → Sprachausgabe:
 - **TTS aktiv**: Global An/Aus
- **F5-TTS Stimme**: Default oder gecloned (Maia etc.)
+- **XTTS Stimme**: Default oder gecloned (Maia, etc.)

-> F5-TTS ist die einzige Engine — wenn die Gamebox offline ist, bleibt ARIA stumm.
+> XTTS ist die einzige Engine — wenn der Gaming-PC offline ist, bleibt ARIA stumm.
 > Chat-Antworten kommen weiter an (nur kein Audio).

 ### Stimme klonen

-1. App oder Diagnostic → "Stimme klonen" → Audio-Dateien hochladen
-   (WAV/MP3, 1-10 Dateien, ~6-10s gesamt)
+1. "Stimme klonen" → Audio-Dateien hochladen (WAV/MP3, 1-10 Dateien, min. 6-10s gesamt)
 2. Name vergeben → "Stimme erstellen"
-3. f5tts-bridge speichert das WAV, schickt einen `stt_request` an die
-   whisper-bridge, legt die Transkription als `.txt` daneben ab und meldet
-   `xtts_voice_saved` zurueck. Der Toast in der App zeigt "Stimme bereit".
-4. Stimme auswaehlen → ein Voice-Preload (stiller Mini-Render) waermt die
-   Latents auf, "voice_ready" Toast bestaetigt es.
+3. "Laden" klicken → neue Stimme in der Auswahl
+4. Stimme auswaehlen → Config wird automatisch gespeichert

 > **Tipp:** Fuer beste Ergebnisse: saubere Aufnahme, eine Stimme, kein Hintergrund,
 > 10-30 Sekunden Gesamtlaenge. Mehrere kurze Dateien werden zusammengefuegt.
@@ -764,15 +720,6 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] "ARIA denkt..."-Indicator + Abbrechen-Button in App (via Bridge → RVS)
 - [x] Whisper-Modell waehlbar in Diagnostic (tiny…large-v3, Hot-Reload)
 - [x] App-Aufnahme explizit 16kHz mono (optimal fuer Whisper, kein Resample)
- [x] Streaming TTS Pre-Roll-Buffer + Wartezeit auf playbackHeadPosition (kein Cutoff mid-Satz mehr)
- [x] Pre-Roll-Buffer einstellbar in App-Settings
- [x] Decimal-zu-Worte fuer TTS + generisches Acronym-Buchstabieren
- [x] voice_preload/voice_ready: visueller Status-Indikator beim Stimmen-Wechsel
- [x] Whisper STT auf die Gamebox ausgelagert (CUDA float16, fast Echtzeit)
- [x] **F5-TTS ersetzt XTTS** — bessere Voice-Cloning-Qualitaet, Whisper-auto-transkribierter Referenz-Text
- [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
- [x] VAD-Stille-Toleranz und Max-Aufnahme einstellbar (1-8s, 120s)
- [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen

 ### Phase 2 — ARIA wird produktiv

@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 506
-        versionName "0.0.5.6"
+        versionCode 407
+        versionName "0.0.4.7"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -53,17 +53,11 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
        promise.resolve(result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
    }

-    /** Andere Apps werden pausiert (TTS spricht).
-     *
-     *  TRANSIENT (statt TRANSIENT_MAY_DUCK): Spotify/YouTube pausieren komplett
-     *  statt nur leiser zu werden. Verhindert auch das "kommt-wieder-hoch"-
-     *  Problem mit MAY_DUCK, wo das System nach kurzer Zeit den Duck-Effekt
-     *  wieder aufgehoben hat obwohl wir den Fokus noch hielten.
-     */
+    /** Andere Apps werden leiser (TTS spricht). */
    @ReactMethod
    fun requestDuck(promise: Promise) {
        requestFocus(
-            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT,
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK,
            AudioAttributes.USAGE_ASSISTANT,
            promise,
        )
@@ -30,10 +30,9 @@ import java.util.concurrent.LinkedBlockingQueue
 class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
    companion object {
        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
-        private const val MAX_PREROLL_SECONDS = 10.0
+        // Sekunden Audio die VOR play()-Start gepuffert sein muessen.
+        // 2.5s Vorrat = genug um XTTS-Render-Pausen zwischen Chunks zu puffern.
+        private const val PREROLL_SECONDS = 2.5
        // Stille am Stream-Anfang, damit AudioTrack sauber anfaehrt und die
        // ersten Samples nicht abgeschnitten werden (XTTS-Warmup + play()-Latenz).
        private const val LEADING_SILENCE_SECONDS = 0.2
@@ -54,21 +53,17 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
    // ── Lifecycle ──

    @ReactMethod
-    fun start(sampleRate: Int, channels: Int, prerollSeconds: Double, promise: Promise) {
+    fun start(sampleRate: Int, channels: Int, promise: Promise) {
        try {
            // 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 }
-
            val channelConfig = if (channels == 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
            val encoding = AudioFormat.ENCODING_PCM_16BIT
            val minBuf = AudioTrack.getMinBufferSize(sampleRate, channelConfig, encoding)
            val bytesPerSecond = sampleRate * channels * 2 // 16-bit = 2 bytes
            // Buffer muss mindestens PREROLL + etwas Spielraum fassen.
-            val prerollTarget = (bytesPerSecond * prerollSec).toInt()
+            val prerollTarget = (bytesPerSecond * PREROLL_SECONDS).toInt()
            val bufferSize = (minBuf * 32).coerceAtLeast(prerollTarget * 2)
            prerollBytes = prerollTarget
            bytesBuffered = 0
@@ -178,7 +173,7 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                }
            }, "PcmStreamWriter").apply { start() }

-            Log.i(TAG, "Stream gestartet: ${sampleRate}Hz ch=$channels buf=${bufferSize}B preroll=${prerollBytes}B (${prerollSec}s)")
+            Log.i(TAG, "Stream gestartet: ${sampleRate}Hz ch=$channels buf=${bufferSize}B preroll=${prerollBytes}B")
            promise.resolve(true)
        } catch (e: Exception) {
            Log.e(TAG, "start fehlgeschlagen", e)
@@ -201,27 +196,11 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
        }
    }

-    /** Signalisiert: keine weiteren Chunks. Writer spielt aus, dann stoppt.
-     *  Das Promise resolved erst wenn der Writer-Thread fertig ist —
-     *  wichtig damit der Aufrufer den AudioFocus erst NACH dem letzten
-     *  abgespielten Sample wieder freigibt (sonst dreht Spotify hoch
-     *  waehrend das Pre-Roll noch ausspielt).
-     */
+    /** Signalisiert: keine weiteren Chunks. Writer wartet auf Queue-Abschluss, dann stoppt. */
    @ReactMethod
    fun end(promise: Promise) {
        endRequested = true
-        val t = writerThread
-        if (t == null || !t.isAlive) {
-            promise.resolve(true)
-            return
-        }
-        // Im Hintergrund auf den Writer warten — kein Threading-Block fuer JS-Bridge
-        Thread({
-            try {
-                t.join(15_000) // hartes Cap, falls Writer haengt
-            } catch (_: InterruptedException) {}
-            promise.resolve(true)
-        }, "PcmStreamEndWaiter").start()
+        promise.resolve(true)
    }

    /** Harter Stop (Cancel) — Queue verwerfen. */
@@ -1,9 +1,7 @@
 buildscript {
    ext {
        buildToolsVersion = "34.0.0"
-        // 24 = Android 7.0 (Nougat). Verlangt von Porcupine (Picovoice).
-        // Realistisch eh das Minimum: alles unter 7.0 hat <1% Marktanteil.
-        minSdkVersion = 24
+        minSdkVersion = 23
        compileSdkVersion = 34
        targetSdkVersion = 34
        ndkVersion = "25.1.8937393"
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.0.5.6",
+  "version": "0.0.4.7",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -24,9 +24,7 @@
    "react-native-camera-kit": "^13.0.0",
    "@react-native-async-storage/async-storage": "^1.21.0",
    "react-native-fs": "^2.20.0",
-    "react-native-audio-recorder-player": "^3.6.7",
-    "@picovoice/porcupine-react-native": "3.0.5",
-    "@picovoice/react-native-voice-processor": "1.2.3"
+    "react-native-audio-recorder-player": "^3.6.7"
  },
  "devDependencies": {
    "typescript": "^5.3.3",
@@ -18,7 +18,6 @@ import {
  Image,
  ScrollView,
  Modal,
-  ToastAndroid,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -29,7 +28,7 @@ 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 { RecordingResult } from '../services/audio';
 import Geolocation from '@react-native-community/geolocation';

 // --- Typen ---
@@ -108,9 +107,6 @@ 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);
@@ -142,11 +138,6 @@ const ChatScreen: React.FC = () => {
    return () => clearInterval(interval);
  }, []);

-  // Wake Word: einmalig laden + Porcupine vorbereiten (wenn Access Key gesetzt)
-  useEffect(() => {
-    wakeWordService.loadFromStorage().catch(() => {});
-  }, []);
-
  const toggleMute = useCallback(() => {
    setTtsMuted(prev => {
      const next = !prev;
@@ -334,44 +325,6 @@ const ChatScreen: React.FC = () => {
        const tool = (message.payload.tool as string) || '';
        setAgentActivity({ activity, tool });
      }
-
-      // Voice-Config aus Diagnostic — setzt die lokale App-Stimme auf den
-      // gerade in Diagnostic gewaehlten Wert zurueck. User-Wahl in der App
-      // wird dadurch ueberschrieben.
-      if (message.type === ('config' as any)) {
-        const newVoice = ((message.payload as any).xttsVoice as string) ?? '';
-        localXttsVoiceRef.current = newVoice;
-        AsyncStorage.setItem('aria_xtts_voice', newVoice);
-      }
-
-      // XTTS-Bridge meldet Stimme fertig geladen (kurzer Status-Toast)
-      if (message.type === ('voice_ready' as any)) {
-        const v = ((message.payload as any).voice as string) ?? '';
-        const err = (message.payload as any).error as string | undefined;
-        if (err) {
-          ToastAndroid.show(`Stimme "${v}" Fehler: ${err}`, ToastAndroid.LONG);
-        } else {
-          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) => {
@@ -411,11 +364,10 @@ const ChatScreen: React.FC = () => {
  useEffect(() => {
    const unsubWake = wakeWordService.onWakeWord(async () => {
      console.log('[Chat] Gespraechsmodus — starte Auto-Aufnahme');
-      // Conversation-Window: User hat X Sekunden um anzufangen, sonst Konversation aus
-      const windowMs = await loadConvWindowMs();
-      const started = await audioService.startRecording(true, windowMs);
+      // Aufnahme mit Auto-Stop (VAD) starten
+      const started = await audioService.startRecording(true);
      if (!started) {
-        // Mikrofon nicht verfuegbar, naechsten Versuch
+        // Mikrofon nicht verfuegbar, Wake Word wieder aktivieren
        wakeWordService.resume();
      }
    });
@@ -424,7 +376,7 @@ const ChatScreen: React.FC = () => {
    const unsubSilence = audioService.onSilenceDetected(async () => {
      const result = await audioService.stopRecording();
      if (result && result.durationMs > 500) {
-        // User hat im Fenster gesprochen → Sprachnachricht senden
+        // Sprachnachricht senden (gleiche Logik wie handleVoiceRecording)
        const location = await getCurrentLocation();
        const userMsg: ChatMessage = {
          id: nextId(),
@@ -441,14 +393,9 @@ const ChatScreen: React.FC = () => {
          voice: localXttsVoiceRef.current,
          ...(location && { location }),
        });
-        // resume() wird durch onPlaybackFinished nach ARIAs Antwort getriggert.
-      } else {
-        // Kein Speech im Window → Konversation beenden (Ohr geht aus oder
-        // bleibt armed wenn Wake Word verfuegbar)
-        wakeWordService.endConversation();
-        // UI-State synchron halten
-        if (!wakeWordService.isActive()) setWakeWordActive(false);
      }
+      // Wake Word wieder aktivieren
+      if (wakeWordActive) wakeWordService.resume();
    });

    return () => {
@@ -785,49 +732,6 @@ 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}>
@@ -1042,25 +946,6 @@ 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,
@@ -15,33 +15,11 @@ import {
  StyleSheet,
  Alert,
  Platform,
-  ToastAndroid,
-  ActivityIndicator,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
 import DocumentPicker from 'react-native-document-picker';
 import rvs, { ConnectionState, RVSMessage, ConnectionConfig, ConnectionLogEntry } from '../services/rvs';
-import {
-  TTS_PREROLL_DEFAULT_SEC,
-  TTS_PREROLL_MIN_SEC,
-  TTS_PREROLL_MAX_SEC,
-  TTS_PREROLL_STORAGE_KEY,
-  VAD_SILENCE_DEFAULT_SEC,
-  VAD_SILENCE_MIN_SEC,
-  VAD_SILENCE_MAX_SEC,
-  VAD_SILENCE_STORAGE_KEY,
-  CONV_WINDOW_DEFAULT_SEC,
-  CONV_WINDOW_MIN_SEC,
-  CONV_WINDOW_MAX_SEC,
-  CONV_WINDOW_STORAGE_KEY,
-} from '../services/audio';
-import wakeWordService, {
-  BUILTIN_KEYWORDS,
-  DEFAULT_KEYWORD,
-  WAKE_ACCESS_KEY_STORAGE,
-  WAKE_KEYWORD_STORAGE,
-} from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
 import VoiceCloneModal from '../components/VoiceCloneModal';
@@ -95,16 +73,8 @@ const SettingsScreen: React.FC = () => {
  const [autoDownload, setAutoDownload] = useState(true);
  const [storageSize, setStorageSize] = useState('...');
  const [ttsEnabled, setTtsEnabled] = useState(true);
-  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 [wakeAccessKey, setWakeAccessKey] = useState<string>('');
-  const [wakeAccessKeyVisible, setWakeAccessKeyVisible] = useState(false);
-  const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
-  const [wakeStatus, setWakeStatus] = useState<string>('');
  const [editingPath, setEditingPath] = useState(false);
  const [xttsVoice, setXttsVoice] = useState('');
-  const [loadingVoice, setLoadingVoice] = useState<string | null>(null);
  const [availableVoices, setAvailableVoices] = useState<Array<{name: string, size: number}>>([]);
  const [voiceCloneVisible, setVoiceCloneVisible] = useState(false);
  const [tempPath, setTempPath] = useState('');
@@ -129,36 +99,6 @@ const SettingsScreen: React.FC = () => {
    AsyncStorage.getItem('aria_tts_enabled').then(saved => {
      if (saved !== null) setTtsEnabled(saved === 'true');
    });
-    AsyncStorage.getItem(TTS_PREROLL_STORAGE_KEY).then(saved => {
-      if (saved != null) {
-        const n = parseFloat(saved);
-        if (isFinite(n) && n >= TTS_PREROLL_MIN_SEC && n <= TTS_PREROLL_MAX_SEC) {
-          setTtsPrerollSec(n);
-        }
-      }
-    });
-    AsyncStorage.getItem(VAD_SILENCE_STORAGE_KEY).then(saved => {
-      if (saved != null) {
-        const n = parseFloat(saved);
-        if (isFinite(n) && n >= VAD_SILENCE_MIN_SEC && n <= VAD_SILENCE_MAX_SEC) {
-          setVadSilenceSec(n);
-        }
-      }
-    });
-    AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY).then(saved => {
-      if (saved != null) {
-        const n = parseFloat(saved);
-        if (isFinite(n) && n >= CONV_WINDOW_MIN_SEC && n <= CONV_WINDOW_MAX_SEC) {
-          setConvWindowSec(n);
-        }
-      }
-    });
-    AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
-      if (saved) setWakeAccessKey(saved);
-    });
-    AsyncStorage.getItem(WAKE_KEYWORD_STORAGE).then(saved => {
-      if (saved) setWakeKeyword(saved);
-    });
    AsyncStorage.getItem('aria_xtts_voice').then(saved => {
      if (saved) setXttsVoice(saved);
    });
@@ -310,31 +250,6 @@ const SettingsScreen: React.FC = () => {
        }
        rvs.send('xtts_list_voices' as any, {});
      }
-
-      // Diagnostic-Voice-Wechsel → lokale App-Stimme auf den neuen Default zuruecksetzen.
-      // Zusaetzlich Preload triggern, damit der User weiss wann's geladen ist.
-      if (message.type === ('config' as any)) {
-        const newVoice = ((message.payload as any).xttsVoice as string) ?? '';
-        setXttsVoice(newVoice);
-        AsyncStorage.setItem('aria_xtts_voice', newVoice);
-        if (newVoice) {
-          setLoadingVoice(newVoice);
-        }
-      }
-
-      // XTTS-Bridge meldet: Stimme fertig geladen
-      if (message.type === ('voice_ready' as any)) {
-        const v = ((message.payload as any).voice as string) ?? '';
-        const err = (message.payload as any).error as string | undefined;
-        const ms = (message.payload as any).loadMs as number | undefined;
-        setLoadingVoice(null);
-        if (err) {
-          ToastAndroid.show(`Stimme "${v}" konnte nicht geladen werden: ${err}`, ToastAndroid.LONG);
-        } else {
-          const suffix = ms ? ` (${(ms / 1000).toFixed(1)}s)` : '';
-          ToastAndroid.show(`Stimme "${v || 'Standard'}" bereit${suffix}`, ToastAndroid.SHORT);
-        }
-      }
    });

    return () => {
@@ -403,13 +318,6 @@ const SettingsScreen: React.FC = () => {
  const selectVoice = useCallback((voiceName: string) => {
    setXttsVoice(voiceName);
    AsyncStorage.setItem('aria_xtts_voice', voiceName);
-    // Preload nur fuer Custom-Voices — "Standard" braucht keinen Ladevorgang
-    if (voiceName) {
-      setLoadingVoice(voiceName);
-      rvs.send('voice_preload' as any, { voice: voiceName, source: 'app' });
-    } else {
-      setLoadingVoice(null);
-    }
  }, []);

  const deleteVoice = useCallback((name: string) => {
@@ -597,154 +505,6 @@ const SettingsScreen: React.FC = () => {
        </View>
      </View>

-      {/* === Spracheingabe (geraetelokal) === */}
-      <Text style={styles.sectionTitle}>Spracheingabe</Text>
-      <View style={styles.card}>
-        <Text style={styles.toggleLabel}>Stille-Toleranz</Text>
-        <Text style={styles.toggleHint}>
-          Wie lange du eine Sprechpause machen darfst, bevor die Aufnahme
-          automatisch beendet und gesendet wird. Hoeher = mehr Zeit zum
-          Nachdenken; niedriger = schnelleres Senden.
-          Default: {VAD_SILENCE_DEFAULT_SEC.toFixed(1)}s.
-        </Text>
-        <View style={styles.prerollRow}>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.max(VAD_SILENCE_MIN_SEC, Math.round((vadSilenceSec - 0.5) * 10) / 10);
-              setVadSilenceSec(next);
-              AsyncStorage.setItem(VAD_SILENCE_STORAGE_KEY, String(next));
-            }}
-            disabled={vadSilenceSec <= VAD_SILENCE_MIN_SEC}
-          >
-            <Text style={styles.prerollButtonText}>−0.5</Text>
-          </TouchableOpacity>
-          <Text style={styles.prerollValue}>{vadSilenceSec.toFixed(1)} s</Text>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.min(VAD_SILENCE_MAX_SEC, Math.round((vadSilenceSec + 0.5) * 10) / 10);
-              setVadSilenceSec(next);
-              AsyncStorage.setItem(VAD_SILENCE_STORAGE_KEY, String(next));
-            }}
-            disabled={vadSilenceSec >= VAD_SILENCE_MAX_SEC}
-          >
-            <Text style={styles.prerollButtonText}>+0.5</Text>
-          </TouchableOpacity>
-        </View>
-
-        <Text style={[styles.toggleLabel, {marginTop: 24}]}>Konversations-Fenster</Text>
-        <Text style={styles.toggleHint}>
-          Im Gespraechsmodus (Ohr-Button): nach ARIA's Antwort hast du so lange
-          Zeit, weiter zu sprechen, bevor die Konversation automatisch beendet wird.
-          Sprichst du nichts → Mikrofon zu.
-          Default: {CONV_WINDOW_DEFAULT_SEC.toFixed(1)}s.
-        </Text>
-        <View style={styles.prerollRow}>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.max(CONV_WINDOW_MIN_SEC, Math.round((convWindowSec - 1) * 10) / 10);
-              setConvWindowSec(next);
-              AsyncStorage.setItem(CONV_WINDOW_STORAGE_KEY, String(next));
-            }}
-            disabled={convWindowSec <= CONV_WINDOW_MIN_SEC}
-          >
-            <Text style={styles.prerollButtonText}>−1</Text>
-          </TouchableOpacity>
-          <Text style={styles.prerollValue}>{convWindowSec.toFixed(0)} s</Text>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.min(CONV_WINDOW_MAX_SEC, Math.round((convWindowSec + 1) * 10) / 10);
-              setConvWindowSec(next);
-              AsyncStorage.setItem(CONV_WINDOW_STORAGE_KEY, String(next));
-            }}
-            disabled={convWindowSec >= CONV_WINDOW_MAX_SEC}
-          >
-            <Text style={styles.prerollButtonText}>+1</Text>
-          </TouchableOpacity>
-        </View>
-      </View>
-
-      {/* === Wake-Word (geraetelokal) === */}
-      <Text style={styles.sectionTitle}>Wake-Word</Text>
-      <View style={styles.card}>
-        <Text style={styles.toggleHint}>
-          Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
-          auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
-          Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
-          ARIA starten. Ohne Key oder bei Fehlschlag startet das Ohr direkt
-          eine Konversation (klassischer Modus).
-        </Text>
-
-        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Picovoice Access Key</Text>
-        <View style={{flexDirection: 'row', alignItems: 'center', gap: 8, marginTop: 6}}>
-          <TextInput
-            style={[styles.input, {flex: 1}]}
-            value={wakeAccessKey}
-            onChangeText={setWakeAccessKey}
-            placeholder="kostenlos auf console.picovoice.ai"
-            placeholderTextColor="#666680"
-            secureTextEntry={!wakeAccessKeyVisible}
-            autoCapitalize="none"
-            autoCorrect={false}
-          />
-          <TouchableOpacity
-            onPress={() => setWakeAccessKeyVisible(v => !v)}
-            style={{padding: 8}}
-          >
-            <Text style={{fontSize: 18}}>{wakeAccessKeyVisible ? '🙈' : '👁'}</Text>
-          </TouchableOpacity>
-        </View>
-
-        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Wake-Word</Text>
-        <Text style={styles.toggleHint}>
-          Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
-          ueber Diagnostic-Upload.
-        </Text>
-        <View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
-          {BUILTIN_KEYWORDS.map(kw => (
-            <TouchableOpacity
-              key={kw}
-              style={[
-                styles.keywordChip,
-                wakeKeyword === kw && styles.keywordChipActive,
-              ]}
-              onPress={() => setWakeKeyword(kw)}
-            >
-              <Text style={[
-                styles.keywordChipText,
-                wakeKeyword === kw && styles.keywordChipTextActive,
-              ]}>
-                {kw}
-              </Text>
-            </TouchableOpacity>
-          ))}
-        </View>
-
-        <View style={{flexDirection: 'row', gap: 8, marginTop: 16, alignItems: 'center'}}>
-          <TouchableOpacity
-            style={[styles.connectButton, {flex: 1}]}
-            onPress={async () => {
-              setWakeStatus('Initialisiere...');
-              try {
-                const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
-                setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
-              } catch (err: any) {
-                setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
-              }
-              setTimeout(() => setWakeStatus(''), 5000);
-            }}
-          >
-            <Text style={styles.connectButtonText}>Speichern + Aktivieren</Text>
-          </TouchableOpacity>
-        </View>
-        {!!wakeStatus && (
-          <Text style={{marginTop: 8, fontSize: 12, color: '#8888AA'}}>{wakeStatus}</Text>
-        )}
-      </View>
-
      {/* === Sprachausgabe (geraetelokal) === */}
      <Text style={styles.sectionTitle}>Sprachausgabe</Text>
      <View style={styles.card}>
@@ -767,53 +527,27 @@ const SettingsScreen: React.FC = () => {
          />
        </View>

-        {ttsEnabled && (
-          <View style={{marginTop: 20}}>
-            <Text style={styles.toggleLabel}>Puffer vor Wiedergabestart</Text>
-            <Text style={styles.toggleHint}>
-              Wie viel Audio gesammelt wird bevor die Wiedergabe startet.
-              Hoeher = robuster gegen Render-Pausen, aber mehr Startverzoegerung.
-              Default: {TTS_PREROLL_DEFAULT_SEC.toFixed(1)}s.
-            </Text>
-            <View style={styles.prerollRow}>
-              <TouchableOpacity
-                style={styles.prerollButton}
-                onPress={() => {
-                  const next = Math.max(TTS_PREROLL_MIN_SEC, Math.round((ttsPrerollSec - 0.5) * 10) / 10);
-                  setTtsPrerollSec(next);
-                  AsyncStorage.setItem(TTS_PREROLL_STORAGE_KEY, String(next));
-                }}
-                disabled={ttsPrerollSec <= TTS_PREROLL_MIN_SEC}
-              >
-                <Text style={styles.prerollButtonText}>−0.5</Text>
-              </TouchableOpacity>
-              <Text style={styles.prerollValue}>{ttsPrerollSec.toFixed(1)} s</Text>
-              <TouchableOpacity
-                style={styles.prerollButton}
-                onPress={() => {
-                  const next = Math.min(TTS_PREROLL_MAX_SEC, Math.round((ttsPrerollSec + 0.5) * 10) / 10);
-                  setTtsPrerollSec(next);
-                  AsyncStorage.setItem(TTS_PREROLL_STORAGE_KEY, String(next));
-                }}
-                disabled={ttsPrerollSec >= TTS_PREROLL_MAX_SEC}
-              >
-                <Text style={styles.prerollButtonText}>+0.5</Text>
-              </TouchableOpacity>
-            </View>
-          </View>
-        )}
-
        {ttsEnabled && (
          <View style={{marginTop: 20}}>
            <Text style={styles.toggleLabel}>Stimme (geraetelokal)</Text>
            <Text style={styles.toggleHint}>
-              Eine geklonte Stimme auswaehlen. F5-TTS braucht zwingend eine Referenz —
-              ohne Auswahl gilt die in Diagnostic gewaehlte globale Stimme.
+              Eigene Wahl fuer dieses Geraet. Ohne Auswahl gilt der Diagnostic-Default.
            </Text>

+            {/* Default-Option */}
+            <TouchableOpacity
+              style={[styles.voiceRow, xttsVoice === '' && styles.voiceRowActive]}
+              onPress={() => selectVoice('')}
+            >
+              <Text style={[styles.voiceRowName, xttsVoice === '' && styles.voiceRowNameActive]}>
+                Standard (Diagnostic-Default)
+              </Text>
+              {xttsVoice === '' && <Text style={styles.voiceRowCheck}>{'\u2713'}</Text>}
+            </TouchableOpacity>
+
            {availableVoices.length === 0 ? (
              <Text style={[styles.toggleHint, {marginTop: 8, textAlign: 'center'}]}>
-                Keine geklonten Stimmen vorhanden — unten "Eigene Stimme aufnehmen".
+                Keine eigenen Stimmen auf dem XTTS-Server.
              </Text>
            ) : (
              availableVoices.map(v => (
@@ -827,10 +561,7 @@ const SettingsScreen: React.FC = () => {
                    </Text>
                    <Text style={styles.voiceRowMeta}>{(v.size / 1024).toFixed(0)} KB</Text>
                  </TouchableOpacity>
-                  {loadingVoice === v.name && (
-                    <ActivityIndicator size="small" color="#0096FF" style={{marginRight: 8}} />
-                  )}
-                  {xttsVoice === v.name && loadingVoice !== v.name && <Text style={styles.voiceRowCheck}>{'\u2713'}</Text>}
+                  {xttsVoice === v.name && <Text style={styles.voiceRowCheck}>{'\u2713'}</Text>}
                  <TouchableOpacity onPress={() => deleteVoice(v.name)} style={styles.voiceRowDelete}>
                    <Text style={styles.voiceRowDeleteIcon}>X</Text>
                  </TouchableOpacity>
@@ -1387,56 +1118,6 @@ const styles = StyleSheet.create({
  bottomSpacer: {
    height: 40,
  },
-
-  prerollRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-    marginTop: 12,
-    gap: 16,
-  },
-  prerollButton: {
-    backgroundColor: '#2A2A3E',
-    paddingHorizontal: 18,
-    paddingVertical: 10,
-    borderRadius: 8,
-    minWidth: 72,
-    alignItems: 'center',
-  },
-  prerollButtonText: {
-    color: '#FFFFFF',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-  prerollValue: {
-    color: '#FFFFFF',
-    fontSize: 20,
-    fontWeight: '700',
-    minWidth: 80,
-    textAlign: 'center',
-  },
-
-  keywordChip: {
-    backgroundColor: '#1E1E2E',
-    borderWidth: 1,
-    borderColor: '#2A2A3E',
-    paddingHorizontal: 12,
-    paddingVertical: 6,
-    borderRadius: 14,
-  },
-  keywordChipActive: {
-    backgroundColor: '#0096FF',
-    borderColor: '#0096FF',
-  },
-  keywordChipText: {
-    color: '#8888AA',
-    fontSize: 13,
-    fontWeight: '500',
-  },
-  keywordChipTextActive: {
-    color: '#FFFFFF',
-    fontWeight: '700',
-  },
 });

 export default SettingsScreen;
@@ -9,7 +9,6 @@
 import { Platform, PermissionsAndroid, NativeModules } from 'react-native';
 import Sound from 'react-native-sound';
 import RNFS from 'react-native-fs';
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import AudioRecorderPlayer, {
  AudioEncoderAndroidType,
  AudioSourceAndroidType,
@@ -42,7 +41,7 @@ const { AudioFocus, PcmStreamPlayer } = NativeModules as {
    release: () => Promise<boolean>;
  };
  PcmStreamPlayer?: {
-    start: (sampleRate: number, channels: number, prerollSeconds: number) => Promise<boolean>;
+    start: (sampleRate: number, channels: number) => Promise<boolean>;
    writeChunk: (base64Pcm: string) => Promise<boolean>;
    end: () => Promise<boolean>;
    stop: () => Promise<boolean>;
@@ -74,73 +73,12 @@ const AUDIO_ENCODING = 'audio/wav';

 // VAD (Voice Activity Detection) — Stille-Erkennung
 const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
+const VAD_SILENCE_DURATION_MS = 1800;  // ms Stille bevor Auto-Stop
 const VAD_SPEECH_THRESHOLD_DB = -28;   // dB ueber dem als "Sprache" gilt (Sprach-Gate) — hoeher = weniger Umgebungsgeraeusche
 const VAD_SPEECH_MIN_MS = 500;         // ms Sprache bevor Aufnahme zaehlt — laenger = keine Huestler/Klopfer mehr

-// VAD-Stille (in Sekunden) — wie lange Sprechpause toleriert wird, bevor
-// die Aufnahme automatisch beendet wird. Einstellbar in den App-Settings.
-export const VAD_SILENCE_DEFAULT_SEC = 2.8;
-export const VAD_SILENCE_MIN_SEC = 1.0;
-export const VAD_SILENCE_MAX_SEC = 8.0;
-export const VAD_SILENCE_STORAGE_KEY = 'aria_vad_silence_sec';
-
-// Konversations-Fenster (in Sekunden) — nach ARIA's Antwort hat der User so
-// lange Zeit, im Gespraechsmodus weiter zu sprechen, ohne dass die Konversation
-// beendet wird. Sprichst du im Fenster nichts → Konversation aus.
-export const CONV_WINDOW_DEFAULT_SEC = 8.0;
-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';
-
-export async function loadConvWindowMs(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= CONV_WINDOW_MIN_SEC && n <= CONV_WINDOW_MAX_SEC) {
-        return Math.round(n * 1000);
-      }
-    }
-  } catch {}
-  return Math.round(CONV_WINDOW_DEFAULT_SEC * 1000);
-}
-
-async function loadVadSilenceMs(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(VAD_SILENCE_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= VAD_SILENCE_MIN_SEC && n <= VAD_SILENCE_MAX_SEC) {
-        return Math.round(n * 1000);
-      }
-    }
-  } catch {}
-  return Math.round(VAD_SILENCE_DEFAULT_SEC * 1000);
-}
-
-// Max-Dauer einer Aufnahme (Notbremse gegen Runaway-Loops). Auf 2 Minuten
-// hochgezogen damit auch laengere Erklaerungen durchgehen.
-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_MAX_SEC = 6.0;
-export const TTS_PREROLL_STORAGE_KEY = 'aria_tts_preroll_sec';
-
-async function loadPrerollSec(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(TTS_PREROLL_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= TTS_PREROLL_MIN_SEC && n <= TTS_PREROLL_MAX_SEC) {
-        return n;
-      }
-    }
-  } catch {}
-  return TTS_PREROLL_DEFAULT_SEC;
-}
+// Max-Dauer einer Aufnahme in Gespraechsmodus (Notbremse gegen Runaway-Loops)
+const MAX_RECORDING_MS = 30000;

 // --- Audio-Service ---

@@ -178,7 +116,6 @@ class AudioService {
  private lastSpeechTime: number = 0;
  private vadTimer: ReturnType<typeof setInterval> | null = null;
  private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
-  private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;

  constructor() {
    this.recorder = new AudioRecorderPlayer();
@@ -211,16 +148,8 @@ class AudioService {

  // --- Aufnahme ---

-  /** Mikrofon-Aufnahme starten.
-   *
-   *  @param autoStop          VAD aktivieren — Auto-Stop bei Stille
-   *  @param noSpeechTimeoutMs Wenn der User innerhalb dieser Zeit nichts sagt,
-   *                           wird Stille gemeldet (Recording wird verworfen).
-   *                           Fuer Conversation-Window: nach ARIA's Antwort
-   *                           hast du nur N Sekunden um anzufangen, sonst
-   *                           Gespraech zu Ende.
-   */
-  async startRecording(autoStop: boolean = false, noSpeechTimeoutMs: number = 0): Promise<boolean> {
+  /** Mikrofon-Aufnahme starten */
+  async startRecording(autoStop: boolean = false): Promise<boolean> {
    if (this.recordingState !== 'idle') {
      console.warn('[Audio] Aufnahme laeuft bereits');
      return false;
@@ -287,14 +216,12 @@ class AudioService {
      // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
      AudioFocus?.requestExclusive().catch(() => {});

-      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar)
+      // VAD aktivieren
      this.vadEnabled = autoStop;
      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) {
+          if (silenceDuration >= VAD_SILENCE_DURATION_MS) {
            console.log(`[Audio] VAD: ${silenceDuration}ms Stille — Auto-Stop`);
            this.silenceListeners.forEach(cb => cb());
          }
@@ -306,18 +233,6 @@ class AudioService {
        }, 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.
-      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());
-          }
-        }, noSpeechTimeoutMs);
-      }
-
      console.log('[Audio] Aufnahme gestartet (autoStop: %s)', autoStop);
      return true;
    } catch (err) {
@@ -344,10 +259,6 @@ class AudioService {
      clearTimeout(this.maxDurationTimer);
      this.maxDurationTimer = null;
    }
-    if (this.noSpeechTimer) {
-      clearTimeout(this.noSpeechTimer);
-      this.noSpeechTimer = null;
-    }

    try {
      await this.recorder.stopRecorder();
@@ -462,9 +373,8 @@ class AudioService {
      this.pcmBuffer = [];
      this.pcmBytesCollected = 0;
      if (!silent) {
-        const prerollSec = await loadPrerollSec();
        try {
-          await PcmStreamPlayer!.start(sampleRate, channels, prerollSec);
+          await PcmStreamPlayer!.start(sampleRate, channels);
        } catch (err) {
          console.error('[Audio] PcmStreamPlayer.start fehlgeschlagen:', err);
          this.pcmStreamActive = false;
@@ -487,10 +397,6 @@ class AudioService {

    if (isFinal) {
      if (!silent) {
-        // end() resolved jetzt erst wenn der native Writer-Thread fertig
-        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
-        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
-        // wieder aufdrehen.
        try { await PcmStreamPlayer!.end(); } catch {}
        AudioFocus?.release().catch(() => {});
      }
@@ -1,218 +1,56 @@
 /**
- * Gespraechsmodus / Wake Word Service
+ * Gespraechsmodus — "Ohr-Button"
 *
- * Drei Zustaende:
- *   off        — Ohr aus, nichts laeuft
- *   armed      — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
- *                Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
- *   conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
- *                aktive Konversation. Porcupine pausiert (gibt Mikro frei),
- *                AudioRecorder uebernimmt fuer die Aufnahme.
- *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
- *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
+ * Wenn aktiv: Nach jeder ARIA-Antwort (TTS fertig) startet automatisch die Aufnahme.
+ * Wie ein Walkie-Talkie / natuerliches Gespraech:
+ *   ARIA spricht → Aufnahme startet → User spricht → VAD stoppt → ARIA antwortet → ...
 *
- * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
- * direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
- * geht dann nach 'off' statt 'armed'.
+ * Phase 2 (geplant): Porcupine "ARIA" Wake Word fuer passives Lauschen.
 */

-import AsyncStorage from '@react-native-async-storage/async-storage';
-
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;

-export type WakeWordState = 'off' | 'armed' | 'conversing';
-
-export const WAKE_ACCESS_KEY_STORAGE = 'aria_wake_access_key';
-export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
-
-/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
- *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
- *  Console — wird spaeter ueber Diagnostic uploadbar. */
-export const BUILTIN_KEYWORDS = [
-  'jarvis',
-  'computer',
-  'picovoice',
-  'porcupine',
-  'bumblebee',
-  'terminator',
-  'alexa',
-  'hey google',
-  'ok google',
-  'hey siri',
-] as const;
-export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
-export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
+export type WakeWordState = 'off' | 'listening' | 'detected';

 class WakeWordService {
  private state: WakeWordState = 'off';
  private wakeCallbacks: WakeWordCallback[] = [];
  private stateCallbacks: StateCallback[] = [];

-  // Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
-  private porcupine: any = null;
-  private accessKey: string = '';
-  private keyword: string = DEFAULT_KEYWORD;
-  private initInProgress: Promise<boolean> | null = null;
-
-  /** Beim App-Start aufrufen — laedt Settings, baut Porcupine wenn Key da ist. */
-  async loadFromStorage(): Promise<void> {
-    try {
-      const k = await AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE);
-      const w = await AsyncStorage.getItem(WAKE_KEYWORD_STORAGE);
-      this.accessKey = (k || '').trim();
-      this.keyword = (w || DEFAULT_KEYWORD).trim();
-      if (this.accessKey) {
-        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
-        await this.initPorcupine();
-      }
-    } catch (err) {
-      console.warn('[WakeWord] loadFromStorage', err);
-    }
-  }
-
-  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
-  async configure(accessKey: string, keyword: string): Promise<boolean> {
-    this.accessKey = (accessKey || '').trim();
-    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
-    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
-    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
-
-    // Laufende Instanz stoppen
-    await this.disposePorcupine();
-    if (!this.accessKey) return false;
-
-    // Neu initialisieren
-    return this.initPorcupine();
-  }
-
-  private async initPorcupine(): Promise<boolean> {
-    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
-        this.porcupine = await PorcupineManager.fromBuiltInKeywords(
-          this.accessKey,
-          [this.keyword],
-          (_keywordIndex: number) => this.onWakeDetected(),
-        );
-        console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
-        return true;
-      } catch (err) {
-        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
-        this.porcupine = null;
-        return false;
-      } finally {
-        this.initInProgress = null;
-      }
-    })();
-    return this.initInProgress;
-  }
-
-  private async disposePorcupine() {
-    if (this.porcupine) {
-      try { await this.porcupine.stop(); } catch {}
-      try { await this.porcupine.delete(); } catch {}
-      this.porcupine = null;
-    }
-  }
-
-  /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
+  /** Gespraechsmodus starten */
  async start(): Promise<boolean> {
-    if (this.state !== 'off') return true;
-    if (this.porcupine) {
-      // Passives Lauschen via Porcupine
-      try {
-        await this.porcupine.start();
-        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
-        this.setState('armed');
-        return true;
-      } catch (err) {
-        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
-      }
-    }
-    // Fallback: direkt in die Konversation
-    console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
-    this.setState('conversing');
+    if (this.state === 'listening') return true;
+    console.log('[WakeWord] Gespraechsmodus aktiviert — starte sofort Aufnahme');
+    this.setState('listening');
+    // Sofort erste Aufnahme starten
    setTimeout(() => {
-      if (this.state === 'conversing') {
+      if (this.state === 'listening') {
        this.wakeCallbacks.forEach(cb => cb());
      }
    }, 500);
    return true;
  }

-  /** Komplett ausschalten (Ohr abschalten) */
-  async stop(): Promise<void> {
-    console.log('[WakeWord] Ohr deaktiviert');
-    if (this.porcupine) {
-      try { await this.porcupine.stop(); } catch {}
-    }
+  /** Gespraechsmodus stoppen */
+  stop(): void {
+    console.log('[WakeWord] Gespraechsmodus deaktiviert');
    this.setState('off');
  }

-  /** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
-  private async onWakeDetected(): Promise<void> {
-    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
-    if (this.porcupine) {
-      try { await this.porcupine.stop(); } catch {}
-    }
-    this.setState('conversing');
-    // kurz warten damit Mikrofon frei ist
-    setTimeout(() => {
-      if (this.state === 'conversing') {
-        this.wakeCallbacks.forEach(cb => cb());
-      }
-    }, 200);
-  }
-
-  /** Konversation beenden — User hat im Window nichts gesagt.
-   *  Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
-   *  Ohne: zurueck zu 'off'.
-   */
-  async endConversation(): Promise<void> {
-    if (this.state !== 'conversing') return;
-    if (this.porcupine && this.accessKey) {
-      try {
-        await this.porcupine.start();
-        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
-        this.setState('armed');
-        return;
-      } catch (err) {
-        console.warn('[WakeWord] re-arm fehlgeschlagen:', err);
-      }
-    }
-    console.log('[WakeWord] Konversation zu Ende — Ohr aus');
-    this.setState('off');
-  }
-
-  /** Nach ARIA-Antwort (TTS fertig): naechste Aufnahme im Conversation-Window starten */
+  /** Nach ARIA-Antwort (TTS fertig): Aufnahme automatisch starten */
  async resume(): Promise<void> {
-    if (this.state !== 'conversing') return;
+    if (this.state !== 'listening') return;
    // Kurze Pause damit TTS-Audio nicht ins Mikrofon geht
    await new Promise(resolve => setTimeout(resolve, 800));
-    if (this.state === 'conversing') {
-      console.log('[WakeWord] TTS fertig — naechste Aufnahme im Conversation-Window');
+    if (this.state === 'listening') {
+      console.log('[WakeWord] TTS fertig — starte automatisch Aufnahme');
      this.wakeCallbacks.forEach(cb => cb());
    }
  }

-  /** True solange das Ohr aktiv ist (armed ODER conversing). */
  isActive(): boolean {
-    return this.state !== 'off';
-  }
-
-  isConversing(): boolean {
-    return this.state === 'conversing';
-  }
-
-  hasWakeWord(): boolean {
-    return !!this.porcupine;
-  }
-
-  getKeyword(): string {
-    return this.keyword;
+    return this.state === 'listening';
  }

  // --- Callbacks ---
@@ -257,12 +257,6 @@ def clean_text_for_tts(text: str) -> str:
    for pat, repl in _UNIT_WORDS:
        t = _re_tts.sub(pat, repl, t)

-    # Generisches Buchstabieren: alle verbleibenden 2-5-Zeichen-Grossbuchstaben-Woerter
-    # (XTTS, USB, DNS, JSON, HTML, ...) → "X T T S". Laeuft NACH der expliziten Liste,
-    # damit TTS/GPU/... schon aufgeloest sind. "WLAN"-artige, die als Wort gesprochen
-    # werden, koennen bei Bedarf explizit in _UNIT_WORDS uebersteuert werden.
-    t = _re_tts.sub(r'\b([A-Z]{2,5})\b', lambda m: " ".join(m.group(1)), t)
-
    # Anfuehrungszeichen
    t = _re_tts.sub(r'["""„`]', '', t)

@@ -325,16 +319,8 @@ class STTEngine:
            Erkannter Text oder leerer String.
        """
        if self.model is None:
-            # Lazy-Load: normalerweise laeuft STT remote auf der Gamebox.
-            # Erst wenn das Fallback hier zuschlaegt, laden wir lokal.
-            logger.info("Lokales Whisper-Fallback — Modell wird nachgeladen...")
-            try:
-                self.initialize()
-            except Exception:
-                logger.exception("Lokales Whisper konnte nicht geladen werden")
-                return ""
-            if self.model is None:
-                return ""
+            logger.error("Whisper-Modell nicht initialisiert")
+            return ""

        try:
            # Audio als float32 normalisieren
@@ -496,7 +482,6 @@ class ARIABridge:
        # Komponenten (TTS: immer XTTS remote, Piper wurde entfernt)
        self.tts_enabled = True
        self.xtts_voice = ""
-        self._f5tts_config: dict = {}
        vc: dict = {}
        # Gespeicherte Voice-Config laden
        try:
@@ -506,16 +491,7 @@ class ARIABridge:
                    vc = json.load(f)
                self.tts_enabled = vc.get("ttsEnabled", True)
                self.xtts_voice = vc.get("xttsVoice", "")
-                # F5-TTS-Felder aufsammeln (werden spaeter via RVS rebroadcastet,
-                # damit die f5tts-bridge auf der Gamebox die Settings auch nach
-                # Restart wiederbekommt — sonst stuende sie auf Hard-Defaults)
-                for k in ("f5ttsModel", "f5ttsCkptFile", "f5ttsVocabFile",
-                          "f5ttsCfgStrength", "f5ttsNfeStep"):
-                    if k in vc:
-                        self._f5tts_config[k] = vc[k]
-                logger.info("Voice-Config geladen: tts=%s voice=%s f5tts=%s",
-                            self.tts_enabled, self.xtts_voice or "default",
-                            self._f5tts_config or "defaults")
+                logger.info("Voice-Config geladen: tts=%s voice=%s", self.tts_enabled, self.xtts_voice or "default")
        except Exception as e:
            logger.warning("Voice-Config laden fehlgeschlagen: %s", e)
        # Whisper-Modell: Config hat Vorrang, dann env/Default (medium)
@@ -541,9 +517,6 @@ 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
-        # 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] = {}

    def initialize(self) -> None:
        """Initialisiert alle Komponenten.
@@ -556,9 +529,8 @@ class ARIABridge:
        logger.info("ARIA Voice Bridge startet...")
        logger.info("=" * 50)

-        # STT wird standardmaessig von der whisper-bridge (Gamebox) erledigt.
-        # Lokales Whisper ist nur Fallback und wird lazy geladen wenn remote nicht
-        # antwortet. Das spart RAM auf der VM und Startup-Zeit.
+        # STT IMMER laden — verarbeitet Audio von der App (braucht kein Sounddevice)
+        self.stt_engine.initialize()

        # Audio-Hardware pruefen (fuer lokales Mikro/Lautsprecher)
        self.audio_available = False
@@ -973,29 +945,6 @@ class ARIABridge:
        except Exception as e:
            logger.debug("[mode] Broadcast fehlgeschlagen: %s", e)

-    async def _broadcast_persisted_config(self) -> None:
-        """Broadcastet die aktuelle voice_config.json einmalig nach RVS-Connect.
-
-        Damit bekommen frisch verbundene Bridges (insbesondere die f5tts-bridge
-        auf der Gamebox nach Container-Restart) die zuletzt in Diagnostic
-        gewaehlten Settings — ohne dass der User in Diagnostic was klicken muss.
-        """
-        try:
-            payload = {
-                "ttsEnabled": getattr(self, "tts_enabled", True),
-                "xttsVoice": getattr(self, "xtts_voice", ""),
-                "whisperModel": self.stt_engine.model_size,
-            }
-            payload.update(getattr(self, "_f5tts_config", {}) or {})
-            await self._send_to_rvs({
-                "type": "config",
-                "payload": payload,
-                "timestamp": int(asyncio.get_event_loop().time() * 1000),
-            })
-            logger.info("[rvs] Persistierte Config broadcastet: %s", payload)
-        except Exception as e:
-            logger.debug("[rvs] Config-Broadcast fehlgeschlagen: %s", e)
-
    def _fetch_active_session(self) -> None:
        """Holt die aktive Session vom Diagnostic-Endpoint."""
        try:
@@ -1065,12 +1014,6 @@ class ARIABridge:
                    # ihren UI-State sofort syncen koennen
                    await self._broadcast_current_mode()

-                    # Persistierte Voice-Config broadcasten — die f5tts-bridge auf
-                    # der Gamebox bekommt damit nach Restart die zuletzt in
-                    # Diagnostic gewaehlten Settings wieder (sonst stuende sie auf
-                    # ihren Hard-Defaults).
-                    asyncio.create_task(self._broadcast_persisted_config())
-
                    # Heartbeat senden (RVS erwartet Ping alle 30s)
                    heartbeat_task = asyncio.create_task(self._rvs_heartbeat())

@@ -1234,10 +1177,7 @@ class ARIABridge:
            return

        elif msg_type == "config":
-            # Konfiguration von App/Diagnostic empfangen + persistent speichern.
-            # Felder die nicht direkt zur aria-bridge gehoeren (f5tts*) werden
-            # nur persistiert; die f5tts-bridge auf der Gamebox empfaengt den
-            # gleichen RVS-Broadcast und reagiert selber.
+            # Konfiguration von App/Diagnostic empfangen + persistent speichern
            changed = False
            if "ttsEnabled" in payload:
                self.tts_enabled = bool(payload["ttsEnabled"])
@@ -1249,21 +1189,11 @@ class ARIABridge:
                changed = True
            if "whisperModel" in payload:
                new_model = payload["whisperModel"]
-                allowed = {"tiny", "base", "small", "medium", "large-v3"}
-                if new_model in allowed and new_model != self.stt_engine.model_size:
-                    logger.info("[rvs] Whisper-Modell → %s (nur Config; Modell laedt Gamebox)",
-                                new_model)
-                    self.stt_engine.model_size = new_model
-                    self.stt_engine.model = None
-                    changed = True
-            # F5-TTS-Felder: einfach persistieren, f5tts-bridge applied selber.
-            for k in ("f5ttsModel", "f5ttsCkptFile", "f5ttsVocabFile",
-                      "f5ttsCfgStrength", "f5ttsNfeStep"):
-                if k in payload:
-                    if not hasattr(self, "_f5tts_config"):
-                        self._f5tts_config = {}
-                    self._f5tts_config[k] = payload[k]
-                    changed = True
+                if new_model and new_model != self.stt_engine.model_size:
+                    logger.info("[rvs] Whisper-Modell Wechsel: %s -> %s (laedt...)", self.stt_engine.model_size, new_model)
+                    loop = asyncio.get_event_loop()
+                    if await loop.run_in_executor(None, self.stt_engine.reload, new_model):
+                        changed = True
            # Persistent speichern in Shared Volume
            if changed:
                try:
@@ -1273,7 +1203,6 @@ class ARIABridge:
                        "xttsVoice": getattr(self, "xtts_voice", ""),
                        "whisperModel": self.stt_engine.model_size,
                    }
-                    config_data.update(getattr(self, "_f5tts_config", {}))
                    with open("/shared/config/voice_config.json", "w") as f:
                        json.dump(config_data, f, indent=2)
                    logger.info("[rvs] Voice-Config gespeichert: %s", config_data)
@@ -1424,117 +1353,22 @@ class ARIABridge:
                        mime_type, duration_ms, len(audio_b64) // 1365)
            asyncio.create_task(self._process_app_audio(audio_b64, mime_type))

-        elif msg_type == "stt_response":
-            # Antwort der whisper-bridge auf unseren stt_request
-            request_id = payload.get("requestId", "")
-            future = self._pending_stt.get(request_id)
-            if future is None or future.done():
-                return
-            error = payload.get("error", "")
-            if error:
-                logger.warning("[rvs] stt_response Fehler: %s", error)
-                future.set_result(None)
-            else:
-                text = payload.get("text", "")
-                stt_ms = payload.get("sttMs", 0)
-                model = payload.get("model", "?")
-                logger.info("[rvs] Remote-STT OK (%s, %dms): '%s'", model, stt_ms, (text or "")[:80])
-                future.set_result(text)
-            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
-
    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."""
-        # Erst Remote versuchen
-        text = await self._stt_remote(audio_b64, mime_type)
-        if text is None:
-            # Remote hat nicht geantwortet → lokales Whisper
-            logger.warning("[rvs] Remote-STT nicht verfuegbar — Fallback auf lokales Whisper")
-            text = await self._stt_local(audio_b64, mime_type)
-        if text is None:
-            return
-
-        if text.strip():
-            logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
-            # ERST an aria-core senden (wichtigster Schritt)
-            await self.send_to_core(text, source="app-voice")
-            # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)
-            # sender="stt" damit Bridge es ignoriert (kein Loop)
-            try:
-                await self._send_to_rvs({
-                    "type": "chat",
-                    "payload": {
-                        "text": text,
-                        "sender": "stt",
-                    },
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
-            except Exception as e:
-                logger.warning("[rvs] STT-Text konnte nicht an RVS gesendet werden: %s", e)
-        else:
-            logger.info("[rvs] Keine Sprache erkannt — ignoriert")
-
-    async def _stt_remote(self, audio_b64: str, mime_type: str) -> Optional[str]:
-        """Schickt Audio an die whisper-bridge und wartet auf stt_response.
-
-        Rueckgabe:
-            str  — erkannter Text (kann leer sein)
-            None — Remote-STT nicht erreichbar oder Fehler/Timeout (→ Fallback)
-        """
-        if self.ws_rvs is None:
-            return None
-
-        request_id = str(uuid.uuid4())
-        loop = asyncio.get_event_loop()
-        future: asyncio.Future = loop.create_future()
-        self._pending_stt[request_id] = future
-
-        try:
-            model = getattr(self.stt_engine, "model_size", "small")
-            logger.info("[rvs] stt_request → whisper-bridge (id=%s, model=%s, %dKB)",
-                        request_id[:8], model, len(audio_b64) // 1365)
-            ok = await self._send_to_rvs({
-                "type": "stt_request",
-                "payload": {
-                    "requestId": request_id,
-                    "audio": audio_b64,
-                    "mimeType": mime_type,
-                    "model": model,
-                    "language": getattr(self.stt_engine, "language", "de"),
-                },
-                "timestamp": int(loop.time() * 1000),
-            })
-            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)
-        except asyncio.TimeoutError:
-            logger.warning("[rvs] Remote-STT Timeout (%.0fs)", self._STT_REMOTE_TIMEOUT_S)
-            return None
-        except Exception as e:
-            logger.warning("[rvs] Remote-STT Fehler: %s", e)
-            return None
-        finally:
-            self._pending_stt.pop(request_id, None)
-
-    async def _stt_local(self, audio_b64: str, mime_type: str) -> Optional[str]:
-        """Lokales Whisper-Fallback: FFmpeg → float32 → stt_engine.transcribe."""
+        """Decodiert App-Audio (Base64 AAC/MP4), konvertiert zu 16kHz PCM, STT, sendet an core."""
        loop = asyncio.get_event_loop()
        tmp_in = None
        tmp_out = None
        try:
+            # Base64 → temp-Datei
            ext = ".mp4" if "mp4" in mime_type else ".wav" if "wav" in mime_type else ".ogg"
            tmp_in = tempfile.NamedTemporaryFile(suffix=ext, delete=False)
            tmp_in.write(base64.b64decode(audio_b64))
            tmp_in.close()

+            # FFmpeg: beliebiges Format → 16kHz mono PCM (raw float32)
            tmp_out = tempfile.NamedTemporaryFile(suffix=".raw", delete=False)
            tmp_out.close()

@@ -1549,34 +1383,55 @@ class ARIABridge:
            )
            if result.returncode != 0:
                logger.error("[rvs] FFmpeg Fehler: %s", result.stderr.decode()[:200])
-                return None
+                return

+            # PCM lesen → numpy float32
            audio_data = np.fromfile(tmp_out.name, dtype=np.float32)
            if len(audio_data) == 0:
                logger.warning("[rvs] Leere Audio-Daten nach Konvertierung")
-                return None
+                return

            duration_s = len(audio_data) / 16000.0
-            logger.info("[rvs] Lokal-STT: %.1fs Audio, model=%s", duration_s, self.stt_engine.model_size)
-            return await loop.run_in_executor(None, self.stt_engine.transcribe, audio_data)
+            logger.info("[rvs] Audio konvertiert: %.1fs, %d samples", duration_s, len(audio_data))
+
+            # STT
+            text = await loop.run_in_executor(None, self.stt_engine.transcribe, audio_data)
+
+            if text.strip():
+                logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
+                # ERST an aria-core senden (wichtigster Schritt)
+                await self.send_to_core(text, source="app-voice")
+                # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)
+                # sender="stt" damit Bridge es ignoriert (kein Loop)
+                try:
+                    await self._send_to_rvs({
+                        "type": "chat",
+                        "payload": {
+                            "text": text,
+                            "sender": "stt",
+                        },
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] STT-Text konnte nicht an RVS gesendet werden: %s", e)
+            else:
+                logger.info("[rvs] Keine Sprache erkannt — ignoriert")
+
        except Exception:
-            logger.exception("[rvs] Lokales STT fehlgeschlagen")
-            return None
+            logger.exception("[rvs] Audio-Verarbeitung fehlgeschlagen")
        finally:
-            for f in (tmp_in, tmp_out):
+            # Temp-Dateien aufraeumen
+            for f in [tmp_in, tmp_out]:
                if f:
                    try:
                        os.unlink(f.name)
                    except OSError:
                        pass

-    async def _send_to_rvs(self, message: dict) -> bool:
-        """Sendet eine Nachricht an die App (via RVS) mit Verbindungs-Check.
-
-        Rueckgabe: True wenn erfolgreich gesendet, False wenn Verbindung tot.
-        """
+    async def _send_to_rvs(self, message: dict) -> None:
+        """Sendet eine Nachricht an die App (via RVS) mit Verbindungs-Check."""
        if self.ws_rvs is None:
-            return False
+            return

        # Ping-Check: Verbindung wirklich aktiv?
        try:
@@ -1590,14 +1445,12 @@ class ARIABridge:
                pass
            self.ws_rvs = None
            # Reconnect wird vom connect_to_rvs Loop uebernommen
-            return False
+            return

        try:
            await self.ws_rvs.send(json.dumps(message))
-            return True
        except Exception:
            logger.warning("[rvs] Sendefehler — RVS nicht erreichbar")
-            return False

    # ── Log-Streaming an die App ─────────────────────────────

@@ -1,16 +0,0 @@
-@echo off
-REM ================================================================
-REM  ARIA - Cleanup-Wrapper fuer Windows
-REM ================================================================
-REM  Ruft cleanup-windows.ps1 mit ExecutionPolicy Bypass auf.
-REM  Funktioniert auch wenn Windows .ps1 direkt nicht startet.
-REM
-REM  Nutzung:
-REM    cleanup-windows.bat stefan
-REM    cleanup-windows.bat stefan -SkipPrune
-REM
-REM  Doppelklick funktioniert NICHT (braucht Username als Param).
-REM  Per Konsole aufrufen.
-REM ================================================================
-
-powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0cleanup-windows.ps1" %*
@@ -1,184 +0,0 @@
-# ================================================================
-#  ARIA - Windows / WSL2 / Docker Desktop VHDX Cleanup
-# ================================================================
-#
-#  Findet alle WSL2 + Docker Desktop ext4.vhdx Files unter
-#  C:\Users\<USER>\AppData\Local\... und kompaktiert sie via diskpart.
-#  Damit bekommst du Speicherplatz zurueck den du IN den Distros/
-#  Containern geloescht hast (z.B. nach `docker system prune`),
-#  der aber von der VHDX bisher nicht freigegeben wurde.
-#
-#  Nutzung (PowerShell als ADMIN, oder via cleanup-windows.bat):
-#    .\cleanup-windows.ps1 stefan
-#    .\cleanup-windows.ps1 -User stefan
-#    .\cleanup-windows.ps1 -User stefan -SkipPrune    # nur compacten
-#    .\cleanup-windows.ps1 -User stefan -PruneOnly    # nur prune
-#
-#  Was passiert:
-#    1. Erst (optional): docker system prune + builder prune in WSL2
-#    2. wsl --shutdown
-#    3. Alle gefundenen .vhdx Files mit diskpart compact vdisk shrinken
-#
-#  Hinweis: diskpart braucht KEINE Hyper-V Tools (anders als Optimize-VHD).
-#
-#  ASCII-only damit Windows-PowerShell 5.1 das File ohne BOM korrekt
-#  parsen kann (UTF-8-Sonderzeichen wuerden sonst als Windows-1252
-#  fehlinterpretiert).
-# ================================================================
-
-[CmdletBinding()]
-param(
-    [Parameter(Mandatory=$true, Position=0,
-               HelpMessage="Dein Windows-Benutzername (z.B. stefan)")]
-    [string]$User,
-
-    [Parameter(HelpMessage="Docker prune ueberspringen - nur compacten")]
-    [switch]$SkipPrune,
-
-    [Parameter(HelpMessage="Docker prune NUR machen, dann beenden")]
-    [switch]$PruneOnly
-)
-
-# Defensive: Process-Scope ExecutionPolicy auf Bypass - verhindert dass
-# Untersaetze (z.B. Module) blockiert werden. Harmless wenn Parent schon
-# Bypass aufgerufen hat.
-try { Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force | Out-Null } catch {}
-
-# Admin-Check + Self-Elevation
-# Wenn nicht als Admin gestartet -> einmal neu starten als Admin, mit
-# ExecutionPolicy Bypass + den Original-Argumenten. User muss nur einmal
-# UAC-Prompt bestaetigen.
-$isAdmin = ([Security.Principal.WindowsPrincipal] `
-    [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(
-    [Security.Principal.WindowsBuiltInRole]::Administrator)
-if (-not $isAdmin) {
-    Write-Host "-> Starte neu als Administrator (mit ExecutionPolicy Bypass)..." -ForegroundColor Yellow
-    $myPath = $MyInvocation.MyCommand.Path
-    $forwardArgs = @("-NoProfile", "-ExecutionPolicy", "Bypass", "-File", "`"$myPath`"")
-    if ($User)      { $forwardArgs += @("-User", $User) }
-    if ($SkipPrune) { $forwardArgs += "-SkipPrune" }
-    if ($PruneOnly) { $forwardArgs += "-PruneOnly" }
-    try {
-        Start-Process powershell.exe -Verb RunAs -ArgumentList $forwardArgs
-    } catch {
-        Write-Host "[FAIL] UAC-Elevation abgebrochen oder fehlgeschlagen." -ForegroundColor Red
-        Write-Host "       Rechtsklick auf PowerShell -> 'Als Administrator ausfuehren'" -ForegroundColor Yellow
-        exit 1
-    }
-    exit 0
-}
-
-$basePath = "C:\Users\$User\AppData\Local"
-if (-not (Test-Path $basePath)) {
-    Write-Host "[FAIL] Pfad existiert nicht: $basePath" -ForegroundColor Red
-    Write-Host "       Pruefe den Benutzernamen." -ForegroundColor Yellow
-    exit 1
-}
-
-Write-Host "================================================================" -ForegroundColor Cyan
-Write-Host "  ARIA Cleanup fuer User: $User" -ForegroundColor Cyan
-Write-Host "================================================================" -ForegroundColor Cyan
-Write-Host ""
-
-# -- 1. Docker prune (in WSL2) -----------------------------------
-if (-not $SkipPrune) {
-    Write-Host "[1/3] Docker Cleanup in WSL2..." -ForegroundColor Yellow
-    Write-Host "      docker system prune -a --volumes -f" -ForegroundColor Gray
-    Write-Host "      docker builder prune -a -f" -ForegroundColor Gray
-    Write-Host ""
-    try {
-        wsl -e bash -c "docker system prune -a --volumes -f && docker builder prune -a -f"
-        Write-Host "      [OK] fertig" -ForegroundColor Green
-    } catch {
-        Write-Host "      [WARN] Docker prune fehlgeschlagen (vielleicht laeuft Docker Desktop nicht?)" -ForegroundColor Yellow
-        Write-Host "             $_" -ForegroundColor Gray
-    }
-    Write-Host ""
-    if ($PruneOnly) {
-        Write-Host "PruneOnly gesetzt - fertig." -ForegroundColor Cyan
-        exit 0
-    }
-}
-
-# -- 2. WSL2 shutdown --------------------------------------------
-Write-Host "[2/3] WSL2 herunterfahren..." -ForegroundColor Yellow
-wsl --shutdown
-Start-Sleep -Seconds 3
-Write-Host "      [OK] fertig" -ForegroundColor Green
-Write-Host ""
-
-# -- 3. VHDX-Files finden + compacten ----------------------------
-Write-Host "[3/3] VHDX-Files suchen + compacten..." -ForegroundColor Yellow
-Write-Host ""
-
-$vhdxFiles = @()
-$vhdxFiles += Get-ChildItem -Path "$basePath\Docker" -Recurse -Filter "*.vhdx" -ErrorAction SilentlyContinue
-$vhdxFiles += Get-ChildItem -Path "$basePath\Packages" -Recurse -Filter "ext4.vhdx" -ErrorAction SilentlyContinue
-$vhdxFiles = $vhdxFiles | Sort-Object FullName -Unique
-
-if ($vhdxFiles.Count -eq 0) {
-    Write-Host "      Keine .vhdx Files gefunden." -ForegroundColor Yellow
-    exit 0
-}
-
-Write-Host "Gefundene Files (vorher):" -ForegroundColor Cyan
-foreach ($f in $vhdxFiles) {
-    $sizeGB = [math]::Round($f.Length / 1GB, 2)
-    Write-Host ("  {0,8} GB  {1}" -f $sizeGB, $f.FullName) -ForegroundColor Gray
-}
-Write-Host ""
-
-$totalBefore = ($vhdxFiles | Measure-Object Length -Sum).Sum
-
-foreach ($f in $vhdxFiles) {
-    Write-Host "-> Compact: $($f.FullName)" -ForegroundColor White
-    $sizeBefore = [math]::Round($f.Length / 1GB, 2)
-
-    # Temporaeres diskpart-Script schreiben
-    $tmp = [System.IO.Path]::GetTempFileName()
-    @"
-select vdisk file="$($f.FullName)"
-attach vdisk readonly
-compact vdisk
-detach vdisk
-exit
-"@ | Out-File -Encoding ASCII -FilePath $tmp
-
-    try {
-        $output = & diskpart /s $tmp 2>&1
-        # Datei neu lesen - Length ist gecacht
-        $newFile = Get-Item $f.FullName
-        $sizeAfter = [math]::Round($newFile.Length / 1GB, 2)
-        $saved = [math]::Round($sizeBefore - $sizeAfter, 2)
-        if ($saved -gt 0) {
-            Write-Host ("  [OK] {0} GB -> {1} GB  (gespart: {2} GB)" -f $sizeBefore, $sizeAfter, $saved) -ForegroundColor Green
-        } else {
-            Write-Host ("  --   {0} GB -> {1} GB  (nichts zu holen - File war schon optimal)" -f $sizeBefore, $sizeAfter) -ForegroundColor DarkGray
-        }
-    } catch {
-        Write-Host "  [FAIL] Fehler: $_" -ForegroundColor Red
-        Write-Host "         diskpart-Output:" -ForegroundColor DarkGray
-        $output | ForEach-Object { Write-Host "         $_" -ForegroundColor DarkGray }
-    } finally {
-        Remove-Item $tmp -ErrorAction SilentlyContinue
-    }
-    Write-Host ""
-}
-
-# -- Zusammenfassung ---------------------------------------------
-$vhdxFilesAfter = @()
-$vhdxFilesAfter += Get-ChildItem -Path "$basePath\Docker" -Recurse -Filter "*.vhdx" -ErrorAction SilentlyContinue
-$vhdxFilesAfter += Get-ChildItem -Path "$basePath\Packages" -Recurse -Filter "ext4.vhdx" -ErrorAction SilentlyContinue
-$vhdxFilesAfter = $vhdxFilesAfter | Sort-Object FullName -Unique
-$totalAfter = ($vhdxFilesAfter | Measure-Object Length -Sum).Sum
-
-$savedTotal = [math]::Round(($totalBefore - $totalAfter) / 1GB, 2)
-
-Write-Host "================================================================" -ForegroundColor Cyan
-Write-Host ("  Gesamt: {0} GB -> {1} GB  (gespart: {2} GB)" -f `
-    [math]::Round($totalBefore / 1GB, 2),
-    [math]::Round($totalAfter / 1GB, 2),
-    $savedTotal) -ForegroundColor Cyan
-Write-Host "================================================================" -ForegroundColor Cyan
-Write-Host ""
-Write-Host "Fertig. Docker Desktop / WSL2 starten ja von alleine wieder beim naechsten Aufruf." -ForegroundColor Green
@@ -127,15 +127,6 @@
  </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>
-
  <!-- 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;">
@@ -446,71 +437,18 @@
          <label class="toggle"><input type="checkbox" id="diag-tts-enabled" checked onchange="sendVoiceConfig()"><span class="slider"></span></label>
        </div>

-        <!-- F5-TTS Stimme (zwingend eine Voice waehlen — F5-TTS braucht eine Referenz) -->
-        <div style="display:flex;align-items:center;gap:12px;margin-bottom:6px;">
-          <label style="color:#8888AA;font-size:12px;">F5-TTS Stimme:</label>
+        <!-- XTTS Stimme -->
+        <div style="display:flex;align-items:center;gap:12px;margin-bottom:12px;">
+          <label style="color:#8888AA;font-size:12px;">XTTS Stimme:</label>
          <select id="diag-xtts-voice" onchange="sendVoiceConfig()" style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
-            <option value="" disabled>(keine Stimme gewaehlt)</option>
+            <option value="">Standard (XTTS Default)</option>
          </select>
          <button class="btn secondary" onclick="loadXTTSVoices()" style="padding:4px 10px;font-size:11px;">Laden</button>
        </div>
-        <div id="voice-status" style="font-size:11px;min-height:14px;margin-bottom:12px;color:#8888AA;"></div>

        <!-- Gecloned Stimmen — Liste mit Loeschen -->
        <div id="xtts-voice-list" style="margin-bottom:12px;"></div>

-        <!-- F5-TTS Modell-Tuning -->
-        <details style="background:#0D0D1A;border:1px solid #2A2A3E;border-radius:6px;padding:10px 12px;margin-bottom:12px;">
-          <summary style="color:#8888AA;font-size:12px;cursor:pointer;">F5-TTS Modell-Tuning (advanced)</summary>
-          <div style="margin-top:10px;display:flex;flex-direction:column;gap:8px;">
-            <div style="color:#8888AA;font-size:11px;">
-              Werden via RVS an die f5tts-bridge auf der Gamebox geschickt.
-              Modell-/Checkpoint-Wechsel triggert einen Reload (~30s).
-              Hardcoded Defaults: F5TTS_v1_Base, cfg_strength=2.5, nfe_step=32.
-            </div>
-
-            <label style="color:#8888AA;font-size:12px;">Modell-ID:</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):
-            </label>
-            <input type="text" id="diag-f5tts-ckpt"
-              placeholder="z.B. aoxo/F5-TTS-German"
-              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):
-            </label>
-            <input type="text" id="diag-f5tts-vocab"
-              placeholder="leer = Default"
-              style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
-
-            <div style="display:flex;gap:12px;">
-              <div style="flex:1;">
-                <label style="color:#8888AA;font-size:12px;">cfg_strength (1.0 - 5.0):</label>
-                <input type="number" id="diag-f5tts-cfg" step="0.1" min="1" max="5"
-                  placeholder="2.5"
-                  style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;width:100%;box-sizing:border-box;">
-                <div style="color:#666680;font-size:10px;">Hoeher = klebt staerker an Referenz</div>
-              </div>
-              <div style="flex:1;">
-                <label style="color:#8888AA;font-size:12px;">nfe_step (8 - 64):</label>
-                <input type="number" id="diag-f5tts-nfe" step="1" min="8" max="64"
-                  placeholder="32"
-                  style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;width:100%;box-sizing:border-box;">
-                <div style="color:#666680;font-size:10px;">Hoeher = bessere Qualitaet, langsamer</div>
-              </div>
-            </div>
-
-            <button class="btn primary" onclick="sendVoiceConfig()" style="padding:6px 14px;font-size:12px;align-self:flex-start;margin-top:6px;">
-              Anwenden
-            </button>
-          </div>
-        </details>
-
        <!-- Voice Cloning -->
        <div style="background:#1E1E2E;border-radius:8px;padding:12px;margin-top:8px;">
          <div style="color:#0096FF;font-size:13px;font-weight:600;margin-bottom:8px;">Stimme klonen</div>
@@ -902,16 +840,6 @@
            const wSel = document.getElementById('diag-whisper-model');
            if (wSel) wSel.value = msg.whisperModel;
          }
-          // F5-TTS Tuning-Felder wiederherstellen (falls gesetzt)
-          const setIfPresent = (id, val) => {
-            const el = document.getElementById(id);
-            if (el && val !== undefined && val !== null && val !== '') el.value = val;
-          };
-          setIfPresent('diag-f5tts-model', msg.f5ttsModel);
-          setIfPresent('diag-f5tts-ckpt', msg.f5ttsCkptFile);
-          setIfPresent('diag-f5tts-vocab', msg.f5ttsVocabFile);
-          setIfPresent('diag-f5tts-cfg', msg.f5ttsCfgStrength);
-          setIfPresent('diag-f5tts-nfe', msg.f5ttsNfeStep);
          return;
        }

@@ -923,30 +851,6 @@
          return;
        }

-        if (msg.type === 'service_status') {
-          updateServiceStatus(msg.payload || {});
-          return;
-        }
-
-        if (msg.type === 'voice_ready') {
-          const v = msg.payload?.voice || '';
-          const err = msg.payload?.error;
-          const ms = msg.payload?.loadMs;
-          const statusEl = document.getElementById('voice-status');
-          if (statusEl) {
-            if (err) {
-              statusEl.textContent = `⚠️ Stimme "${v}" Fehler: ${err}`;
-              statusEl.style.color = '#FF3B30';
-            } else {
-              statusEl.textContent = `✅ Stimme "${v || 'Standard'}" bereit${ms ? ` (${(ms/1000).toFixed(1)}s)` : ''}`;
-              statusEl.style.color = '#34C759';
-            }
-            setTimeout(() => { if (statusEl) statusEl.textContent = ''; }, 5000);
-          }
-          addLog('info', 'xtts', err ? `Voice "${v}": ${err}` : `Voice "${v || 'Standard'}" bereit`);
-          return;
-        }
-
        if (msg.type === 'watchdog') {
          const colors = { warning: '#FFD60A', fixing: '#FF9500', fixed: '#34C759', error: '#FF3B30' };
          const color = colors[msg.status] || '#FFD60A';
@@ -1466,68 +1370,6 @@
      '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'),
@@ -1708,24 +1550,7 @@
      const ttsEnabled = document.getElementById('diag-tts-enabled').checked;
      const xttsVoice = document.getElementById('diag-xtts-voice').value;
      const whisperModel = document.getElementById('diag-whisper-model').value;
-      const f5ttsModel = document.getElementById('diag-f5tts-model')?.value || '';
-      const f5ttsCkptFile = document.getElementById('diag-f5tts-ckpt')?.value || '';
-      const f5ttsVocabFile = document.getElementById('diag-f5tts-vocab')?.value || '';
-      const f5ttsCfgRaw = document.getElementById('diag-f5tts-cfg')?.value || '';
-      const f5ttsNfeRaw = document.getElementById('diag-f5tts-nfe')?.value || '';
-      const f5ttsCfgStrength = f5ttsCfgRaw ? parseFloat(f5ttsCfgRaw) : undefined;
-      const f5ttsNfeStep = f5ttsNfeRaw ? parseInt(f5ttsNfeRaw, 10) : undefined;
-      send({
-        action: 'send_voice_config',
-        ttsEnabled, xttsVoice, whisperModel,
-        f5ttsModel, f5ttsCkptFile, f5ttsVocabFile,
-        f5ttsCfgStrength, f5ttsNfeStep,
-      });
-      const statusEl = document.getElementById('voice-status');
-      if (statusEl && xttsVoice) {
-        statusEl.textContent = `⏳ Stimme "${xttsVoice}" wird geladen...`;
-        statusEl.style.color = '#FFD60A';
-      }
+      send({ action: 'send_voice_config', ttsEnabled, xttsVoice, whisperModel });
    }

    // ── Passwort-Feld Anzeigen/Verbergen ─────────────────────
@@ -626,33 +626,6 @@ function connectRVS(forcePlain) {
        // Mode-Broadcast von der Bridge → an Browser-Clients weiterreichen
        log("info", "rvs", `Mode-Broadcast: ${msg.payload?.mode} (${msg.payload?.name})`);
        broadcast({ type: "mode", payload: msg.payload });
-      } else if (msg.type === "voice_ready") {
-        // XTTS-Bridge meldet Stimme fertig geladen → an Browser durchreichen
-        const v = msg.payload?.voice || "";
-        const err = msg.payload?.error;
-        const ms = msg.payload?.loadMs;
-        if (err) {
-          log("warn", "rvs", `Voice-Ready Fehler fuer "${v}": ${err}`);
-        } else {
-          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 {
        log("debug", "rvs", `Nachricht: ${JSON.stringify(msg).slice(0, 150)}`);
      }
@@ -1439,25 +1412,6 @@ 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;
-        }
-        if (msg.f5ttsCfgStrength !== undefined && !isNaN(msg.f5ttsCfgStrength)) {
-          voiceConfig.f5ttsCfgStrength = msg.f5ttsCfgStrength;
-        }
-        if (msg.f5ttsNfeStep !== undefined && !isNaN(msg.f5ttsNfeStep)) {
-          voiceConfig.f5ttsNfeStep = msg.f5ttsNfeStep;
-        }
        try {
          fs.mkdirSync("/shared/config", { recursive: true });
          fs.writeFileSync("/shared/config/voice_config.json", JSON.stringify(voiceConfig, null, 2));
@@ -5,7 +5,7 @@
 - [x] Bildupload funktioniert (Shared Volume /shared/uploads/)
 - [x] Sprachnachrichten werden als Text angezeigt (STT → Chat-Bubble)
 - [x] Cache leeren + Auto-Download von Anhaengen
- [x] ARIA liest Nachrichten vor (TTS via Piper, später ersetzt)
+- [x] ARIA liest Nachrichten vor (TTS via Piper)
 - [x] Autoscroll zur letzten Nachricht (inverted FlatList)
 - [x] Bilder im Chat groesser + Vollbild-Vorschau
 - [x] Ohr-Button → Gespraechsmodus (Auto-Aufnahme nach ARIA-Antwort)
@@ -16,11 +16,11 @@
 - [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
 - [x] Grosse Nachrichten satzweise aufteilen fuer TTS
 - [x] RVS Nachrichten vom Smartphone gehen durch
- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme — durch XTTS/F5-TTS ersetzt)
+- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme)
 - [x] Highlight-Trigger konfigurierbar in Diagnostic
- [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning) — durch F5-TTS ersetzt
+- [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning)
 - [x] XTTS Voice Cloning (Audio-Samples hochladen, eigene Stimme)
- [x] TTS Engine waehlbar (Piper/XTTS) — Piper raus, XTTS raus, jetzt nur F5-TTS
+- [x] TTS Engine waehlbar (Piper/XTTS) in Diagnostic + App
 - [x] Auto-Update System (APK via RVS WebSocket)
 - [x] Auto-Update: APK-Installation via FileProvider
 - [x] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
@@ -31,66 +31,49 @@
 - [x] Markdown-Bereinigung fuer TTS (fett, kursiv, code, links, etc.)
 - [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
 - [x] Diagnostic: Sessions als Markdown exportieren (Download-Button)
- [x] Speech Gate: Aufnahme wird verworfen wenn keine Sprache erkannt
- [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten
- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
+- [x] Speech Gate: Aufnahme wird verworfen wenn keine Sprache erkannt (verhindert dass Umgebungsgeraeusche an Whisper gehen)
+- [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten (sessionFromFile-Flag, atomic write)
+- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen (pipelineEnd broadcastet immer idle, auch bei Timeout/Fehler/Disconnect)
 - [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
- [x] Whisper STT: Model-Auswahl in Diagnostic (tiny/base/small/medium/large-v3), Hot-Reload
+- [x] Whisper STT: Model-Auswahl in Diagnostic (tiny/base/small/medium/large-v3), Hot-Reload in Bridge, Default auf medium
 - [x] App: Audio-Aufnahme explizit 16kHz mono (spart Resample, optimal fuer Whisper)
- [x] Streaming TTS: PCM-Stream → AudioTrack MODE_STREAM, keine WAV-Gaps
- [x] Piper komplett entfernt
- [x] Gespraechsmodus: Speech-Gate strenger (-28dB / 500ms)
- [x] Diagnostic: Archivierte Session-Versionen (.reset.*) angezeigt + exportierbar
- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer Session-JSONL zu Markdown
- [x] NO_REPLY-Filter in Bridge + Diagnostic
- [x] Audio-Ducking + Exklusiv-Focus (Kotlin AudioFocusModule)
- [x] TTS-Cleanup serverseitig: Code-Bloecke raus, Einheiten ausgeschrieben, Abkuerzungen buchstabiert, URLs zu "ein Link"
- [x] QR-Code Onboarding: Diagnostic generiert QR, App scannt
- [x] TTS-Audio-Cache im Filesystem: WAV pro messageId, Play-Button spielt aus Cache
- [x] Config via Diagnostic: RVS-Credentials + Auth-Token persistiert in /shared/config/runtime.json
- [x] Disk-Voll Banner in Diagnostic: rotes Overlay + copy-baren Cleanup-Befehlen (safe + aggressiv)
- [x] cleanup.sh: kombinierter Docker-Aufraeum-Befehl (safe / --full)
- [x] Streaming TTS Pre-Roll: AudioTrack play() startet erst wenn 2.5s gepuffert sind
- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
- [x] Leading-Silence (200ms) am Stream-Anfang — AudioTrack faehrt sauber an
- [x] Pre-Roll-Buffer einstellbar in App-Settings (1.0-6.0s, Default 3.5s)
- [x] Fade-In auf erstem PCM-Chunk (120ms) — versteckt XTTS/F5-TTS Warmup-Glitches
- [x] Decimal-zu-Worte fuer TTS (0.1 → null komma eins, mit IP-Schutz-Lookahead)
- [x] Generic Acronym-Buchstabieren (XTTS → X T T S, USB → U S B, ueber expliziter Liste)
- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
- [x] voice_preload/voice_ready: Stille Mini-Render bei Voice-Wechsel + Toast/Status "bereit"
- [x] Whisper STT auf die Gamebox ausgelagert (faster-whisper CUDA, float16) — neuer aria-whisper-bridge Container
- [x] aria-bridge: STT primaer remote (Gamebox), Fallback lokal nach 45s Timeout
- [x] Whisper-Modell hot-swap auf Gamebox via config-Broadcast aus Diagnostic
- [x] **F5-TTS ersetzt XTTS komplett** — neuer aria-f5tts-bridge Container, Voice Cloning, satzweises Streaming
- [x] Voice-Upload mit Whisper-Auto-Transkription — User muss keinen Referenz-Text eintippen
- [x] Audio-Pause statt Ducking: Spotify/YouTube pausieren komplett waehrend TTS (TRANSIENT statt MAY_DUCK)
- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
- [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] Streaming TTS (Weg A): XTTS → PCM-Stream → aria-bridge → App AudioTrack MODE_STREAM, keine WAV-Gaps mehr
+- [x] Piper komplett entfernt: nur noch XTTS v2 als TTS-Engine (remote, GPU auf Gaming-PC). Wenn XTTS offline ist, ist ARIA stumm — bewusst akzeptiert.
+- [x] Gespraechsmodus: Speech-Gate strenger (-28dB / 500ms) — keine Umgebungsgeraeusche mehr
+- [x] Gespraechsmodus: Max-Dauer 30s pro Aufnahme, Cache-Cleanup alter Files, Messages-Array gekappt (500)
+- [x] Diagnostic: Archivierte Session-Versionen (.reset.*) werden angezeigt + exportierbar — OpenClaw resettet Sessions bei erster Nutzung nach Container-Restart, Inhalt ist aber in .reset.<timestamp> Dateien gesichert
+- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer beliebige Session-JSONL zu Markdown
+- [x] NO_REPLY-Filter in Bridge + Diagnostic — still verworfen (kein Chat, kein TTS)
+- [x] Audio-Ducking + Exklusiv-Focus (Kotlin AudioFocusModule): andere Apps leiser bei TTS, pausiert bei Aufnahme
+- [x] TTS-Cleanup serverseitig: Code-Bloecke raus, Einheiten ausgeschrieben (22GB → Gigabyte), Abkuerzungen buchstabiert (CPU), URLs zu "ein Link". `<voice></voice>` Tag wird bevorzugt wenn ARIA ihn liefert.
+- [x] QR-Code Onboarding: Diagnostic generiert QR, App scannt (bestehender QRScanner funktioniert out of the box)
+- [x] TTS-Audio-Cache im Filesystem: Piper-Audio wird mit messageId verknuepft, als WAV in DocumentDirectory/tts_cache gespeichert, Play-Button spielt aus Cache statt regenerieren
+- [x] Config via Diagnostic: RVS-Credentials + Aria-Auth-Token via /api/runtime-config, persistiert in /shared/config/runtime.json, Bridge liest beim Start (Overrides der ENV)

 ## Offen

-### Bugs
+### Bugs (Prioritaet)
+- [ ] App: Audioausgabe hoert ab und zu einfach auf (mitten im Satz oder zwischen Chunks)
 - [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)

 ### 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)
+- [ ] Audio-Ducking: andere App-Audio-Ausgaben leiser stellen waehrend ARIA spricht (AudioFocus API)
+- [ ] Audio-Muten waehrend Aufnahme/Ohr-Modus: andere Audio stumm (wie WhatsApp-Sprachaufnahme)
+- [ ] Spracheingabe-Timeout erhoehen fuer laengere Texte
+- [ ] Generierte TTS-Audiodaten in der Chat-Nachricht einbetten (oder lokal cachen), Play-Button spielt aus Cache statt Regenerierung via XTTS. Base64 im Tag <soundfile></soundfile> (invisible) oder lokaler Datei-Cache mit Referenz in der Message.
+- [ ] QR-Code Onboarding: Diagnostic generiert QR mit RVS-Credentials, App scannt — keine manuelle Eingabe mehr

 ### 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
+- [ ] Audio-Normalisierung (Lautstaerke zwischen Chunks angleichen)

 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
 - [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)
 - [ ] Diagnostic: System-Info Tab (Container-Status, Disk, RAM, CPU)
 - [ ] RVS Zombie-Connections endgueltig loesen
- [ ] Alle .env-Variablen ueber Diagnostic konfigurierbar machen (Fallback .env bleibt fuer initialen Bootstrap)
- [ ] Gamebox: kleine Web-Oberflaeche fuer Credentials/Server-Config oder zentral aus Diagnostic per RVS push
- [ ] Root-Cause OpenClaw Session-Reset: Herausfinden warum Sessions beim ersten chat.send nach Container-Restart verworfen werden
+- [ ] Alle .env-Variablen ueber Diagnostic konfigurierbar machen (kein File-Sync mehr noetig, da alle ARIA-Container auf der gleichen VM laufen). Fallback .env bleibt fuer initialen Bootstrap.
+- [ ] XTTS-Container: kleine Web-Oberflaeche fuer Credentials/Server-Config, oder zentral aus Diagnostic per RVS push
+- [ ] Root-Cause OpenClaw Session-Reset: Herausfinden warum Sessions beim ersten chat.send nach Container-Restart verworfen werden (abortedLastRun / systemSent Theorie pruefen, ggf. Flag preemptiv patchen)
@@ -19,9 +19,6 @@ const ALLOWED_TYPES = new Set([
  "agent_activity", "cancel_request",
  "audio_pcm",
  "xtts_delete_voice",
-  "voice_preload", "voice_ready",
-  "stt_request", "stt_response",
-  "service_status",
 ]);

 // Token-Raum: token -> { clients: Set<ws> }
@@ -4,7 +4,7 @@
 # ════════════════════════════════════════════════

 # RVS Verbindung (gleiche Daten wie auf der ARIA-VM)
-RVS_HOST=example.com
+RVS_HOST=mobil.hacker-net.de
 RVS_PORT=444
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
@@ -1,5 +0,0 @@
-# Voice-Samples (lokal, gehoert nicht ins Repo)
-voices/
-
-# Docker .env
-.env
@@ -0,0 +1,5 @@
+FROM node:22-alpine
+WORKDIR /app
+COPY bridge.js package.json ./
+RUN npm install --production
+CMD ["node", "bridge.js"]
@@ -0,0 +1,486 @@
+/**
+ * ARIA XTTS Bridge — Verbindet XTTS v2 Server mit dem RVS
+ *
+ * Empfaengt tts_request ueber RVS → rendert Audio via XTTS API → sendet zurueck
+ * Empfaengt voice_upload → speichert Voice-Sample fuer Cloning
+ * Empfaengt xtts_list_voices → listet verfuegbare Stimmen
+ */
+
+const WebSocket = require("ws");
+const http = require("http");
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+
+const XTTS_API_URL = process.env.XTTS_API_URL || "http://xtts:8000";
+const RVS_HOST = process.env.RVS_HOST || "";
+const RVS_PORT = process.env.RVS_PORT || "443";
+const RVS_TLS = process.env.RVS_TLS || "true";
+const RVS_TLS_FALLBACK = process.env.RVS_TLS_FALLBACK || "true";
+const RVS_TOKEN = process.env.RVS_TOKEN || "";
+const VOICES_DIR = "/voices";
+
+function log(msg) {
+  console.log(`[${new Date().toISOString()}] ${msg}`);
+}
+
+// ── RVS Verbindung ──────────────────────────────────
+
+let rvsWs = null;
+let retryDelay = 2;
+
+function connectRVS(forcePlain) {
+  if (!RVS_HOST || !RVS_TOKEN) {
+    log("RVS nicht konfiguriert — beende");
+    process.exit(1);
+  }
+
+  const useTls = RVS_TLS === "true" && !forcePlain;
+  const proto = useTls ? "wss" : "ws";
+  const url = `${proto}://${RVS_HOST}:${RVS_PORT}?token=${RVS_TOKEN}`;
+
+  log(`Verbinde zu RVS: ${proto}://${RVS_HOST}:${RVS_PORT}`);
+
+  const ws = new WebSocket(url);
+
+  ws.on("open", () => {
+    log("RVS verbunden — warte auf TTS-Requests");
+    rvsWs = ws;
+    retryDelay = 2;
+
+    // Keepalive
+    setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.ping();
+        ws.send(JSON.stringify({ type: "heartbeat", timestamp: Date.now() }));
+      }
+    }, 25000);
+  });
+
+  ws.on("message", async (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+
+      if (msg.type === "xtts_request") {
+        await handleTTSRequest(msg.payload);
+      } else if (msg.type === "voice_upload") {
+        await handleVoiceUpload(msg.payload);
+      } else if (msg.type === "xtts_list_voices") {
+        await handleListVoices();
+      } else if (msg.type === "xtts_delete_voice") {
+        await handleDeleteVoice(msg.payload);
+      }
+    } catch (err) {
+      log(`Fehler: ${err.message}`);
+    }
+  });
+
+  ws.on("close", () => {
+    log("RVS Verbindung geschlossen");
+    rvsWs = null;
+    setTimeout(() => connectRVS(), Math.min(retryDelay * 1000, 30000));
+    retryDelay = Math.min(retryDelay * 2, 30);
+  });
+
+  ws.on("error", (err) => {
+    log(`RVS Fehler: ${err.message}`);
+    if (useTls && RVS_TLS_FALLBACK === "true") {
+      log("TLS fehlgeschlagen — Fallback auf ws://");
+      ws.removeAllListeners();
+      try { ws.close(); } catch (_) {}
+      connectRVS(true);
+    }
+  });
+}
+
+// ── TTS Request Handler ─────────────────────────────
+
+// ── TTS-Queue ──────────────────────────────────────
+// XTTS verarbeitet Requests sequenziell, damit Streams sich nicht ueberlappen.
+// Ohne Queue wuerden parallele Requests parallel streamen → App bekommt
+// interleaved PCM-Chunks aus zwei Rendern → klingt wie Chaos.
+let ttsQueue = Promise.resolve();
+
+function handleTTSRequest(payload) {
+  ttsQueue = ttsQueue.then(() => _runTTSRequest(payload)).catch(err => {
+    log(`TTS-Queue Fehler: ${err.message}`);
+  });
+  return ttsQueue;
+}
+
+async function _runTTSRequest(payload) {
+  const { text, voice, requestId, language, messageId } = payload;
+  if (!text) return;
+
+  // Markdown-Cleanup (Bridge macht jetzt auch Cleanup, aber safety net)
+  let cleanText = text
+    .replace(/\*\*([^*]+)\*\*/g, "$1")
+    .replace(/\*([^*]+)\*/g, "$1")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/```[\s\S]*?```/g, "")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+    .replace(/#{1,6}\s*/g, "")
+    .replace(/>\s*/g, "")
+    .replace(/[-*]\s+/g, "")
+    .replace(/\n{2,}/g, ". ")
+    .replace(/\n/g, ", ")
+    .replace(/\s{2,}/g, " ")
+    .replace(/["""„]/g, "")
+    .replace(/\(\)/g, "")
+    .trim();
+
+  log(`TTS-Request (streaming): "${cleanText.slice(0, 80)}..." (${cleanText.length} chars, voice: ${voice || "default"})`);
+
+  try {
+    const voiceSample = voice ? path.join(VOICES_DIR, `${voice}.wav`) : null;
+    const hasCustomVoice = voiceSample && fs.existsSync(voiceSample);
+
+    let chunkIndex = 0;
+    let pcmMeta = null;
+
+    const onChunk = (pcmBase64, meta) => {
+      if (!pcmMeta) pcmMeta = meta;
+      sendToRVS({
+        type: "audio_pcm",
+        payload: {
+          requestId: requestId || "",
+          messageId: messageId || "",
+          base64: pcmBase64,
+          format: "pcm_s16le",
+          sampleRate: meta.sampleRate,
+          channels: meta.channels,
+          voice: voice || "default",
+          chunk: chunkIndex++,
+          final: false,
+        },
+        timestamp: Date.now(),
+      });
+    };
+
+    // /tts_stream fuer echtes Streaming (funktioniert im XTTS local-Mode).
+    // Wenn Server im apiManual/api-Mode laeuft: 400 → Fallback auf /tts_to_audio/.
+    try {
+      await streamXTTSAsPCM(
+        cleanText,
+        language || "de",
+        hasCustomVoice ? voiceSample : null,
+        onChunk,
+      );
+    } catch (streamErr) {
+      log(`/tts_stream fehlgeschlagen (${streamErr.message.slice(0, 100)}) — Fallback /tts_to_audio/`);
+      await streamXTTSBatch(
+        cleanText,
+        language || "de",
+        hasCustomVoice ? voiceSample : null,
+        onChunk,
+      );
+    }
+
+    // Am Ende: final-Flag damit App weiss "fertig" und Cache geschrieben werden kann
+    if (pcmMeta) {
+      sendToRVS({
+        type: "audio_pcm",
+        payload: {
+          requestId: requestId || "",
+          messageId: messageId || "",
+          base64: "",
+          format: "pcm_s16le",
+          sampleRate: pcmMeta.sampleRate,
+          channels: pcmMeta.channels,
+          voice: voice || "default",
+          chunk: chunkIndex++,
+          final: true,
+        },
+        timestamp: Date.now(),
+      });
+    }
+
+    log(`TTS komplett: ${chunkIndex} PCM-Frames gestreamt (${cleanText.length} chars)`);
+  } catch (err) {
+    log(`TTS Fehler: ${err.message}`);
+    sendToRVS({
+      type: "xtts_response",
+      payload: { requestId, error: err.message },
+      timestamp: Date.now(),
+    });
+  }
+}
+
+/**
+ * Ruft /tts_stream auf — echter Streaming-Endpoint bei daswer123.
+ * Schickt was der Server verlangt (allow: GET), aber mit JSON-Body
+ * als POST scheitert mit 405. Manche Versionen wollen GET + Query,
+ * andere POST + JSON. Testen was funktioniert.
+ */
+function streamXTTSAsPCM(text, language, speakerWav, onPcmChunk) {
+  return new Promise((resolve, reject) => {
+    // Wichtig: speaker_wav MUSS als Query-Key dabei sein (Pydantic required) —
+    // auch bei default-voice mit leerem Wert. Sonst gibt's HTTP 422.
+    // stream_chunk_size=250: grosse Chunks = wenige Chunk-Grenzen = wenig
+    // Render-Artefakte. daswer123 erzeugt an Chunk-Boundaries haeufig Glitches
+    // in den Worten die ueber die Grenze gehen. Hoehere Latenz ist OK.
+    const qs = new URLSearchParams();
+    qs.set("text", text);
+    qs.set("language", language || "de");
+    qs.set("speaker_wav", speakerWav || "");
+    qs.set("stream_chunk_size", "250");
+
+    const url = new URL(XTTS_API_URL);
+    const fullPath = `/tts_stream?${qs.toString()}`;
+    const options = {
+      hostname: url.hostname,
+      port: url.port || 80,
+      path: fullPath,
+      method: "GET",
+      timeout: 60000,
+    };
+
+    log(`TTS GET /tts_stream?text=${text.slice(0, 30)}... (voice=${speakerWav ? "custom" : "default"})`);
+
+    const req = http.request(options, (res) => {
+      if (res.statusCode !== 200) {
+        let body = "";
+        res.on("data", (d) => { body += d.toString(); });
+        res.on("end", () => {
+          log(`XTTS /tts_stream ${res.statusCode}: ${body.slice(0, 300)}`);
+          reject(new Error(`XTTS HTTP ${res.statusCode}: ${body.slice(0, 200)}`));
+        });
+        return;
+      }
+      log(`TTS stream verbunden, empfange PCM...`);
+
+      let headerParsed = false;
+      let sampleRate = 24000;
+      let channels = 1;
+      let leftover = Buffer.alloc(0); // ungerade Byte-Reste fuer das naechste Chunk
+      const HEADER_BYTES = 44;
+      let headerBuf = Buffer.alloc(0);
+      const PCM_CHUNK_BYTES = 8192; // ~170ms bei 24kHz s16 mono
+
+      res.on("data", (chunk) => {
+        let data = chunk;
+
+        // WAV-Header konsumieren (44 Bytes)
+        if (!headerParsed) {
+          headerBuf = Buffer.concat([headerBuf, data]);
+          if (headerBuf.length < HEADER_BYTES) return;
+          // Header lesen
+          const header = headerBuf.slice(0, HEADER_BYTES);
+          try {
+            channels = header.readUInt16LE(22);
+            sampleRate = header.readUInt32LE(24);
+          } catch (_) {}
+          headerParsed = true;
+          data = headerBuf.slice(HEADER_BYTES);
+        }
+
+        // leftover aus vorherigem Chunk + neuer data
+        let combined = Buffer.concat([leftover, data]);
+
+        // In PCM_CHUNK_BYTES-Happen zerlegen (Vielfache von 2 damit keine Sample-Splits)
+        while (combined.length >= PCM_CHUNK_BYTES) {
+          const slice = combined.slice(0, PCM_CHUNK_BYTES);
+          combined = combined.slice(PCM_CHUNK_BYTES);
+          onPcmChunk(slice.toString("base64"), { sampleRate, channels });
+        }
+        leftover = combined;
+      });
+
+      res.on("end", () => {
+        // Rest-Daten senden
+        if (leftover.length > 0) {
+          onPcmChunk(leftover.toString("base64"), { sampleRate, channels });
+        }
+        resolve();
+      });
+
+      res.on("error", reject);
+    });
+
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("XTTS API Timeout (60s)")); });
+    req.end();
+  });
+}
+
+/**
+ * Fallback: /tts_to_audio/ (POST JSON) — rendert komplett, dann response.
+ * Kein echtes Streaming, aber stabil als Backup wenn /tts_stream nicht geht.
+ * Shared chunking-Logik mit streamXTTSAsPCM — parst WAV-Header, stueckelt PCM.
+ */
+function streamXTTSBatch(text, language, speakerWav, onPcmChunk) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      text,
+      language: language || "de",
+      speaker_wav: speakerWav || "",
+    });
+    const url = new URL(XTTS_API_URL);
+    const options = {
+      hostname: url.hostname,
+      port: url.port || 80,
+      path: "/tts_to_audio/",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+      },
+      timeout: 60000,
+    };
+
+    const req = http.request(options, (res) => {
+      if (res.statusCode !== 200) {
+        let rb = "";
+        res.on("data", (d) => { rb += d.toString(); });
+        res.on("end", () => reject(new Error(`XTTS Batch HTTP ${res.statusCode}: ${rb.slice(0, 200)}`)));
+        return;
+      }
+      let headerParsed = false;
+      let sampleRate = 24000;
+      let channels = 1;
+      let leftover = Buffer.alloc(0);
+      let headerBuf = Buffer.alloc(0);
+      const HEADER_BYTES = 44;
+      const PCM_CHUNK_BYTES = 8192;
+
+      res.on("data", (chunk) => {
+        let data = chunk;
+        if (!headerParsed) {
+          headerBuf = Buffer.concat([headerBuf, data]);
+          if (headerBuf.length < HEADER_BYTES) return;
+          const header = headerBuf.slice(0, HEADER_BYTES);
+          try { channels = header.readUInt16LE(22); sampleRate = header.readUInt32LE(24); } catch (_) {}
+          headerParsed = true;
+          data = headerBuf.slice(HEADER_BYTES);
+        }
+        let combined = Buffer.concat([leftover, data]);
+        while (combined.length >= PCM_CHUNK_BYTES) {
+          const slice = combined.slice(0, PCM_CHUNK_BYTES);
+          combined = combined.slice(PCM_CHUNK_BYTES);
+          onPcmChunk(slice.toString("base64"), { sampleRate, channels });
+        }
+        leftover = combined;
+      });
+      res.on("end", () => {
+        if (leftover.length > 0) onPcmChunk(leftover.toString("base64"), { sampleRate, channels });
+        resolve();
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("XTTS Batch Timeout (60s)")); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// ── Voice Upload Handler ────────────────────────────
+
+async function handleVoiceUpload(payload) {
+  const { name, samples } = payload;
+  if (!name || !samples || !Array.isArray(samples) || samples.length === 0) {
+    log("Voice Upload: Ungueltige Daten");
+    return;
+  }
+
+  log(`Voice Upload: "${name}" (${samples.length} Samples)`);
+
+  try {
+    // Alle Samples zusammenfuegen
+    const buffers = samples.map(s => Buffer.from(s.base64, "base64"));
+    const combined = Buffer.concat(buffers);
+
+    // Als WAV speichern
+    fs.mkdirSync(VOICES_DIR, { recursive: true });
+    const filePath = path.join(VOICES_DIR, `${name.replace(/[^a-zA-Z0-9_-]/g, "_")}.wav`);
+    fs.writeFileSync(filePath, combined);
+
+    log(`Voice gespeichert: ${filePath} (${(combined.length / 1024).toFixed(0)}KB)`);
+
+    sendToRVS({
+      type: "xtts_voice_saved",
+      payload: { name, size: combined.length, path: filePath },
+      timestamp: Date.now(),
+    });
+  } catch (err) {
+    log(`Voice Upload Fehler: ${err.message}`);
+  }
+}
+
+// ── Voice Delete Handler ────────────────────────────
+
+async function handleDeleteVoice(payload) {
+  const { name } = payload || {};
+  if (!name || typeof name !== "string") {
+    log("Voice Delete: ungueltiger Name");
+    return;
+  }
+  const safe = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const filePath = path.join(VOICES_DIR, `${safe}.wav`);
+  try {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      log(`Voice geloescht: ${filePath}`);
+    } else {
+      log(`Voice Delete: Datei existiert nicht (${filePath})`);
+    }
+    // Aktualisierte Liste an alle Clients senden
+    await handleListVoices();
+  } catch (err) {
+    log(`Voice Delete Fehler: ${err.message}`);
+  }
+}
+
+// ── Voice List Handler ──────────────────────────────
+
+async function handleListVoices() {
+  try {
+    const files = fs.existsSync(VOICES_DIR)
+      ? fs.readdirSync(VOICES_DIR).filter(f => f.endsWith(".wav"))
+      : [];
+
+    const voices = files.map(f => ({
+      name: path.basename(f, ".wav"),
+      file: f,
+      size: fs.statSync(path.join(VOICES_DIR, f)).size,
+    }));
+
+    log(`Stimmen: ${voices.length} verfuegbar`);
+
+    sendToRVS({
+      type: "xtts_voices_list",
+      payload: { voices },
+      timestamp: Date.now(),
+    });
+  } catch (err) {
+    log(`Stimmen-Liste Fehler: ${err.message}`);
+  }
+}
+
+// ── RVS senden ──────────────────────────────────────
+
+function sendToRVS(msg) {
+  if (rvsWs && rvsWs.readyState === WebSocket.OPEN) {
+    rvsWs.send(JSON.stringify(msg));
+  }
+}
+
+// ── Start ───────────────────────────────────────────
+
+log("ARIA XTTS Bridge startet...");
+log(`XTTS API: ${XTTS_API_URL}`);
+log(`RVS: ${RVS_HOST}:${RVS_PORT}`);
+
+// Warten bis XTTS API erreichbar ist
+function waitForXTTS(callback, attempts) {
+  if (attempts <= 0) { log("XTTS API nicht erreichbar — starte trotzdem"); callback(); return; }
+  http.get(`${XTTS_API_URL}/docs`, (res) => {
+    log(`XTTS API erreichbar (HTTP ${res.statusCode})`);
+    callback();
+  }).on("error", () => {
+    log(`XTTS API noch nicht bereit — warte (${attempts} Versuche uebrig)...`);
+    setTimeout(() => waitForXTTS(callback, attempts - 1), 10000); // 10s statt 5s (Model laden dauert)
+  });
+}
+
+waitForXTTS(() => connectRVS(), 30); // Max 5min warten
@@ -1,7 +1,7 @@
 # ════════════════════════════════════════════════
-#  ARIA Gamebox Stack — GPU F5-TTS + Whisper STT
+#  ARIA XTTS v2 — GPU TTS Server
 #  Laeuft auf dem Gaming-PC (RTX 3060)
-#  Verbindet sich zum RVS fuer TTS/STT-Requests
+#  Verbindet sich zum RVS fuer TTS-Requests
 # ════════════════════════════════════════════════
 #
 #  Voraussetzungen:
@@ -10,18 +10,15 @@
 #    - .env mit RVS-Verbindungsdaten
 #
 #  Start: docker compose up -d
+#  Test:  curl http://localhost:8000/docs
 # ════════════════════════════════════════════════

 services:

-  # ─── F5-TTS Bridge (GPU) ──────────────────────
-  # Ersetzt den frueheren XTTS-Stack. Empfaengt xtts_request via RVS,
-  # rendert via F5-TTS mit Voice-Cloning, streamt PCM an die App.
-  # Voice-Upload: speichert WAV und laesst whisper-bridge den Referenz-
-  # text transkribieren — der User muss nichts eintippen.
-  f5tts-bridge:
-    build: ./f5tts
-    container_name: aria-f5tts-bridge
+  # ─── XTTS v2 API Server (GPU) ─────────────────
+  xtts:
+    image: daswer123/xtts-api-server:latest
+    container_name: aria-xtts
    deploy:
      resources:
        reservations:
@@ -29,54 +26,37 @@ services:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
+    ports:
+      - "8000:8020"
    volumes:
-      - ./voices:/voices                         # WAV + TXT Referenz
-                                                 # KEIN HF-Cache-Mount mehr —
-                                                 # Modell wird beim Start neu
-                                                 # gezogen. Diagnostic zeigt
-                                                 # "TTS laedt..." Banner bis
-                                                 # service_status: ready kommt.
+      - xtts-models:/app/xtts_models             # Model-Cache (~2GB)
+      - ./voices:/voices                        # Custom Voice Samples
    environment:
-      # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
-      # nfe_step, Custom-Checkpoint) kommen ueber Diagnostic via RVS-config.
-      - RVS_HOST=${RVS_HOST}
-      - RVS_PORT=${RVS_PORT:-443}
-      - RVS_TLS=${RVS_TLS:-true}
-      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
-      - RVS_TOKEN=${RVS_TOKEN}
-      - F5TTS_DEVICE=${F5TTS_DEVICE:-cuda}
-      - VOICES_DIR=/voices
+      - COQUI_TOS_AGREED=1
+      # Local-Modus statt default "apiManual": Modell bleibt im GPU-VRAM,
+      # Render startet sofort, /tts_stream funktioniert.
+      # Default-CMD des Images liest diese ENV: -ms ${MODEL_SOURCE:-"apiManual"}
+      - MODEL_SOURCE=local
+      # Speaker-Folder auf unsere gemounteten voices zeigen lassen
+      - EXAMPLE_FOLDER=/voices
    restart: unless-stopped

-  # ─── Whisper STT (GPU) ────────────────────────
-  # Faster-Whisper auf der Gamebox statt auf der VM (CPU) —
-  # deutlich schneller. Verbindet sich selbst per WebSocket an
-  # den RVS und nimmt dort stt_request Nachrichten der aria-bridge
-  # entgegen, antwortet mit stt_response. Zusaetzlich nutzt die
-  # f5tts-bridge Whisper intern fuer die Referenz-Transkription bei
-  # Voice-Uploads. Laedt das Modell beim Start vor; auf Config-
-  # Broadcasts (Diagnostic → whisperModel) wird zur Laufzeit hot-
-  # swapped.
-  whisper-bridge:
-    build: ./whisper
-    container_name: aria-whisper-bridge
-    deploy:
-      resources:
-        reservations:
-          devices:
-            - driver: nvidia
-              count: 1
-              capabilities: [gpu]
+  # ─── XTTS Bridge (verbindet zu RVS) ───────────
+  xtts-bridge:
+    build: .
+    container_name: aria-xtts-bridge
+    depends_on:
+      - xtts
+    volumes:
+      - ./voices:/voices                        # Shared mit XTTS-Server
    environment:
+      - XTTS_API_URL=http://xtts:8020
      - RVS_HOST=${RVS_HOST}
      - RVS_PORT=${RVS_PORT:-443}
      - RVS_TLS=${RVS_TLS:-true}
      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
      - RVS_TOKEN=${RVS_TOKEN}
-      - WHISPER_MODEL=${WHISPER_MODEL:-small}
-      - WHISPER_DEVICE=${WHISPER_DEVICE:-cuda}
-      - WHISPER_COMPUTE_TYPE=${WHISPER_COMPUTE_TYPE:-float16}
-      - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-de}
-    # KEIN HF-Cache-Mount — Whisper-Modell wird beim Start neu gezogen.
-    # Wechsel via Diagnostic triggert ebenso Re-Download.
    restart: unless-stopped
+
+volumes:
+  xtts-models:
@@ -1,21 +0,0 @@
-FROM nvidia/cuda:12.2.2-cudnn8-runtime-ubuntu22.04
-
-ENV DEBIAN_FRONTEND=noninteractive
-ENV PYTHONUNBUFFERED=1
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    python3 python3-pip ffmpeg git \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-# PyTorch CUDA-Wheels zuerst (f5-tts zieht sonst CPU-only Torch rein)
-RUN pip3 install --no-cache-dir torch==2.3.1 torchaudio==2.3.1 \
-    --index-url https://download.pytorch.org/whl/cu121
-
-COPY requirements.txt .
-RUN pip3 install --no-cache-dir -r requirements.txt
-
-COPY bridge.py .
-
-CMD ["python3", "bridge.py"]
@@ -1,732 +0,0 @@
-#!/usr/bin/env python3
-"""
-ARIA F5-TTS Bridge — laeuft auf der Gamebox (RTX 3060).
-
-Empfaengt xtts_request via RVS → F5-TTS Voice Cloning auf GPU → streamt
-16-bit PCM Chunks als audio_pcm Nachrichten zurueck an die App.
-
-Voice-Layout im VOICES_DIR:
-  {name}.wav   — Referenz-Audio (6-10s, 24kHz mono empfohlen)
-  {name}.txt   — Referenz-Text (UTF-8, was im WAV gesprochen wird)
-
-Beim voice_upload senden wir intern einen stt_request an die whisper-bridge
-und legen die Transkription als .txt ab — der User muss keinen Text eingeben.
-
-Env:
-  RVS_HOST, RVS_PORT, RVS_TLS, RVS_TLS_FALLBACK, RVS_TOKEN
-  F5TTS_MODEL   Default: F5TTS_v1_Base
-  F5TTS_DEVICE  Default: cuda
-  VOICES_DIR    Default: /voices
-"""
-import asyncio
-import base64
-import json
-import logging
-import os
-import re
-import subprocess
-import sys
-import tempfile
-import time
-import uuid
-from pathlib import Path
-from typing import Optional
-
-import numpy as np
-import soundfile as sf
-import websockets
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%H:%M:%S",
-)
-logger = logging.getLogger("f5tts-bridge")
-# HuggingFace + Torch download-Logs etwas daempfen
-logging.getLogger("httpx").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-
-RVS_HOST = os.getenv("RVS_HOST", "").strip()
-RVS_PORT = int(os.getenv("RVS_PORT", "443"))
-RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
-RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
-RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
-
-# F5-TTS Konfiguration
-# ─────────────────────────────────────────────────────────────────
-# Defaults sind hard-coded — bewusst KEINE ENV-Vars (ausser F5TTS_DEVICE,
-# weil Hardware-Bootstrap). Alle Settings werden zur Laufzeit via RVS
-# config-Broadcast aus Diagnostic uebersteuert (Felder f5ttsModel,
-# f5ttsCkptFile, f5ttsVocabFile, f5ttsCfgStrength, f5ttsNfeStep).
-F5TTS_DEVICE = os.getenv("F5TTS_DEVICE", "cuda")  # nur Bootstrap
-
-DEFAULT_F5TTS_MODEL = "F5TTS_v1_Base"
-DEFAULT_F5TTS_CKPT_FILE = ""        # leer = Default-Checkpoint von HF
-DEFAULT_F5TTS_VOCAB_FILE = ""       # leer = Default-Vocab vom Modell
-# cfg_strength: wie stark der Generator am Referenz-Voice klebt.
-# Default F5-TTS = 2.0. Bei nicht-EN/CN Sprachen (Deutsch!) hilft 2.5+,
-# damit das Modell nicht in eine andere Sprache abrutscht.
-DEFAULT_F5TTS_CFG_STRENGTH = 2.5
-DEFAULT_F5TTS_NFE_STEP = 32
-
-VOICES_DIR = Path(os.getenv("VOICES_DIR", "/voices"))
-
-PCM_CHUNK_BYTES = 8192   # ~170ms @ 24kHz mono s16
-TARGET_SR = 24000        # F5-TTS native
-
-# Wird in einer Uebergangsphase als "ungueltige Referenz" erkannt (alte voices,
-# die hochgeladen wurden bevor die whisper-bridge online war). Bei Erkennung
-# loeschen wir die .txt und ziehen den echten Text nach.
-_LEGACY_PLACEHOLDER_REF = "Das ist ein Referenz Audio."
-
-# ── Lazy F5-TTS Loader ──────────────────────────────────────
-
-_F5TTS_cls = None
-
-
-def _get_f5tts_cls():
-    """Lazy import damit Startup-Logs nicht durch Torch-Warnungen zumuellen."""
-    global _F5TTS_cls
-    if _F5TTS_cls is None:
-        from f5_tts.api import F5TTS as _cls
-        _F5TTS_cls = _cls
-    return _F5TTS_cls
-
-
-class F5Runner:
-    """Haelt das F5-TTS-Modell. Synthese laeuft im Executor (blocking).
-
-    Live-Settings (Modell, cfg_strength, nfe_step) werden ueber update_config()
-    aus dem Diagnostic-Config-Broadcast gesetzt; bei Modell-Wechsel wird
-    automatisch neu geladen.
-    """
-
-    def __init__(self) -> None:
-        self.model = None
-        self._lock = asyncio.Lock()
-        # Aktuelle Werte — gestartet mit Hard-Defaults, ueberschrieben von Diagnostic
-        self.model_id: str = DEFAULT_F5TTS_MODEL
-        self.ckpt_file: str = DEFAULT_F5TTS_CKPT_FILE
-        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()
-        logger.info("Lade F5-TTS '%s' (device=%s, ckpt=%s)...",
-                    self.model_id, F5TTS_DEVICE, self.ckpt_file 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
-        self.model = cls(**kwargs)
-        elapsed = time.time() - self._load_started_at
-        logger.info("F5-TTS geladen in %.1fs (cfg_strength=%.1f, nfe=%d)",
-                    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:
-            if self.model is not None:
-                return
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, self._load_blocking)
-
-    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 ""
-        try:
-            new_cfg = float(payload.get("f5ttsCfgStrength", self.cfg_strength))
-        except (TypeError, ValueError):
-            new_cfg = self.cfg_strength
-        try:
-            new_nfe = int(payload.get("f5ttsNfeStep", self.nfe_step))
-        except (TypeError, ValueError):
-            new_nfe = self.nfe_step
-
-        # Settings die KEINEN Modell-Reload brauchen (zur naechsten Synthese aktiv)
-        self.cfg_strength = new_cfg
-        self.nfe_step = new_nfe
-
-        # Settings die einen Reload triggern
-        model_changed = (new_model != self.model_id
-                         or new_ckpt != self.ckpt_file
-                         or new_vocab != self.vocab_file)
-        if model_changed:
-            logger.info("F5-TTS Config-Wechsel: model=%s ckpt=%s vocab=%s — Reload",
-                        new_model, new_ckpt or "default", new_vocab or "default")
-            self.model_id = new_model
-            self.ckpt_file = new_ckpt
-            self.vocab_file = new_vocab
-            async with self._lock:
-                old = self.model
-                self.model = None
-                # Alte Instanz freigeben
-                try:
-                    if old is not None:
-                        del old
-                except Exception:
-                    pass
-                loop = asyncio.get_event_loop()
-                await loop.run_in_executor(None, self._load_blocking)
-        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]:
-        wav, sr, _ = self.model.infer(
-            ref_file=ref_wav,
-            ref_text=ref_text,
-            gen_text=gen_text,
-            remove_silence=True,
-            seed=-1,
-            cfg_strength=self.cfg_strength,
-            nfe_step=self.nfe_step,
-        )
-        # F5-TTS gibt float32 1D-Array — auf 24kHz sample-rate standard
-        if not isinstance(wav, np.ndarray):
-            wav = np.asarray(wav, dtype=np.float32)
-        if wav.ndim > 1:
-            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]:
-        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)
-
-
-# ── Helpers ─────────────────────────────────────────────────
-
-_SENTENCE_SPLIT = re.compile(r"(?<=[.!?])\s+|\n+")
-
-
-def split_sentences(text: str, max_len: int = 350) -> list[str]:
-    """Teilt langen Text an Satzgrenzen. Kurze Texte bleiben als-is."""
-    text = text.strip()
-    if not text:
-        return []
-    if len(text) <= max_len:
-        return [text]
-    parts = [p.strip() for p in _SENTENCE_SPLIT.split(text) if p.strip()]
-    # Zu kurze Fragmente mergen damit F5-TTS nicht an jedem Komma neu startet
-    merged: list[str] = []
-    buf = ""
-    for p in parts:
-        if len(buf) + len(p) + 1 <= max_len:
-            buf = f"{buf} {p}".strip()
-        else:
-            if buf:
-                merged.append(buf)
-            buf = p
-    if buf:
-        merged.append(buf)
-    return merged or [text]
-
-
-def float_to_pcm16(wav: np.ndarray) -> bytes:
-    """Float32 (-1..+1) → int16 little-endian bytes."""
-    wav = np.clip(wav, -1.0, 1.0)
-    pcm = (wav * 32767.0).astype(np.int16)
-    return pcm.tobytes()
-
-
-def sanitize_voice_name(name: str) -> str:
-    return re.sub(r"[^a-zA-Z0-9_-]", "_", name)
-
-
-def voice_paths(name: str) -> tuple[Path, Path]:
-    safe = sanitize_voice_name(name)
-    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.
-
-    Wenn das File schon passt, wird nichts geaendert. Sonst wird es
-    reingeschrieben (Original wird ueberschrieben).
-    """
-    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")
-    cmd = ["ffmpeg", "-y", "-i", str(src_wav),
-           "-ar", str(TARGET_SR), "-ac", "1", "-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])
-        try:
-            tmp_out.unlink()
-        except OSError:
-            pass
-        return src_wav
-    os.replace(tmp_out, src_wav)
-    return src_wav
-
-
-async def _send(ws, mtype: str, payload: dict) -> None:
-    try:
-        await ws.send(json.dumps({
-            "type": mtype,
-            "payload": payload,
-            "timestamp": int(time.time() * 1000),
-        }))
-    except Exception as e:
-        logger.warning("Send fehlgeschlagen (%s): %s", mtype, e)
-
-
-# ── Interne Transkription via whisper-bridge ────────────────
-
-_pending_stt: dict[str, asyncio.Future] = {}
-_STT_TIMEOUT_S = 60.0
-
-
-async def request_transcription(ws, wav_path: Path, language: str = "de") -> Optional[str]:
-    """Sendet einen stt_request an die whisper-bridge (ueber RVS) und wartet auf stt_response."""
-    try:
-        with open(wav_path, "rb") as f:
-            audio_b64 = base64.b64encode(f.read()).decode("ascii")
-    except Exception as e:
-        logger.error("Lesen %s fehlgeschlagen: %s", wav_path, e)
-        return None
-
-    request_id = str(uuid.uuid4())
-    loop = asyncio.get_event_loop()
-    fut: asyncio.Future = loop.create_future()
-    _pending_stt[request_id] = fut
-
-    try:
-        await _send(ws, "stt_request", {
-            "requestId": request_id,
-            "audio": audio_b64,
-            "mimeType": "audio/wav",
-            "model": "small",  # klein reicht fuer Voice-Referenz
-            "language": language,
-        })
-        return await asyncio.wait_for(fut, timeout=_STT_TIMEOUT_S)
-    except asyncio.TimeoutError:
-        logger.warning("Transkription Timeout fuer %s", wav_path.name)
-        return None
-    except Exception as e:
-        logger.warning("Transkription Fehler: %s", e)
-        return None
-    finally:
-        _pending_stt.pop(request_id, None)
-
-
-# ── TTS-Request Handler ─────────────────────────────────────
-
-# Queue damit sich parallele Requests nicht ueberlappen (GPU-Throughput)
-_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()
-        try:
-            await _do_tts(ws, runner, text, voice, request_id, message_id, language)
-        except Exception:
-            logger.exception("TTS-Worker Fehler")
-        finally:
-            _tts_queue.task_done()
-
-
-async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
-                  request_id: str, message_id: str, language: str) -> None:
-    t0 = time.time()
-    ref_wav_path, ref_txt_path = voice_paths(voice) if voice else (None, None)
-
-    # Legacy-Platzhalter erkennen → behandeln als "kein txt" und neu transkribieren
-    if voice and ref_txt_path and ref_txt_path.exists():
-        try:
-            existing = ref_txt_path.read_text(encoding="utf-8").strip()
-            if existing == _LEGACY_PLACEHOLDER_REF or not existing:
-                logger.info("Voice '%s' hat Legacy-Platzhalter → loesche, transkribiere neu", voice)
-                ref_txt_path.unlink()
-        except Exception:
-            pass
-
-    has_custom = bool(voice and ref_wav_path and ref_wav_path.exists() and ref_txt_path.exists())
-    if voice and not has_custom:
-        # Wenn nur WAV da ist aber kein txt → on-the-fly transkribieren
-        if ref_wav_path and ref_wav_path.exists() and (not ref_txt_path or not ref_txt_path.exists()):
-            logger.info("Voice '%s' hat kein txt — transkribiere on-the-fly", voice)
-            text_ref = await request_transcription(ws, ref_wav_path, language)
-            if text_ref and text_ref.strip():
-                try:
-                    ref_txt_path.write_text(text_ref.strip(), encoding="utf-8")
-                    has_custom = True
-                    logger.info("Referenz-Text nachgezogen: '%s'", text_ref[:60])
-                except Exception as e:
-                    logger.warning("Referenz-Text speichern fehlgeschlagen: %s", e)
-        if not has_custom:
-            logger.warning("Voice '%s' nicht komplett (%s, txt=%s) — nehme Default",
-                           voice, ref_wav_path, (ref_txt_path and ref_txt_path.exists()))
-
-    if has_custom:
-        ref_wav_str = str(ref_wav_path)
-        ref_text = ref_txt_path.read_text(encoding="utf-8").strip()
-    else:
-        # Fallback: kein Custom-Voice. F5-TTS braucht IMMER eine Referenz,
-        # wir nehmen default_ref.wav/txt falls vorhanden, sonst die erste
-        # gefundene Voice im Ordner.
-        default_wav = VOICES_DIR / "default_ref.wav"
-        default_txt = VOICES_DIR / "default_ref.txt"
-        if default_wav.exists() and default_txt.exists():
-            ref_wav_str = str(default_wav)
-            ref_text = default_txt.read_text(encoding="utf-8").strip()
-        else:
-            # Nimm irgendein vorhandenes voice-Paar
-            pair = next(
-                ((w, t) for w, t in (
-                    (v, v.with_suffix(".txt")) for v in VOICES_DIR.glob("*.wav")
-                ) if t.exists()),
-                None,
-            )
-            if not pair:
-                logger.error("Keine Referenz-Stimme im VOICES_DIR — TTS abgebrochen")
-                return
-            ref_wav_str, ref_text = str(pair[0]), pair[1].read_text(encoding="utf-8").strip()
-
-    sentences = split_sentences(text)
-    logger.info("F5-TTS: %d Satz(e), voice=%s (%s)", len(sentences), voice or "default", ref_wav_str)
-
-    chunk_index = 0
-    pcm_sr = TARGET_SR
-    for i, sent in enumerate(sentences):
-        try:
-            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text)
-            pcm_sr = sr
-            pcm_bytes = float_to_pcm16(wav)
-            # Erste PCM-Chunk des allerersten Satzes bekommt Fade-In (maskiert
-            # eventuelle Warmup-Glitches). Alle anderen Chunks bleiben wie sind.
-            if i == 0 and chunk_index == 0:
-                pcm_bytes = _fade_in_pcm16(pcm_bytes, sr, 120)
-
-            # Stueckeln
-            for off in range(0, len(pcm_bytes), PCM_CHUNK_BYTES):
-                slice_ = pcm_bytes[off:off + PCM_CHUNK_BYTES]
-                await _send(ws, "audio_pcm", {
-                    "requestId": request_id,
-                    "messageId": message_id,
-                    "base64": base64.b64encode(slice_).decode("ascii"),
-                    "format": "pcm_s16le",
-                    "sampleRate": sr,
-                    "channels": 1,
-                    "voice": voice or "default",
-                    "chunk": chunk_index,
-                    "final": False,
-                })
-                chunk_index += 1
-        except Exception as e:
-            logger.exception("F5-TTS Synthese-Fehler (Satz %d)", i)
-            await _send(ws, "xtts_response", {
-                "requestId": request_id,
-                "error": str(e)[:200],
-            })
-            return
-
-    # Final-Marker
-    await _send(ws, "audio_pcm", {
-        "requestId": request_id,
-        "messageId": message_id,
-        "base64": "",
-        "format": "pcm_s16le",
-        "sampleRate": pcm_sr,
-        "channels": 1,
-        "voice": voice or "default",
-        "chunk": chunk_index,
-        "final": True,
-    })
-
-    logger.info("TTS komplett: %d Chunks, %.2fs render (voice=%s, text=%d chars)",
-                chunk_index, time.time() - t0, voice or "default", len(text))
-
-
-def _fade_in_pcm16(pcm: bytes, sr: int, fade_ms: int) -> bytes:
-    """Linear Fade-In auf erste fade_ms — maskiert Warmup-Glitches."""
-    arr = np.frombuffer(pcm, dtype=np.int16).copy()
-    fade_samples = min(int((fade_ms / 1000.0) * sr), len(arr))
-    if fade_samples <= 0:
-        return pcm
-    ramp = np.linspace(0.0, 1.0, fade_samples, dtype=np.float32)
-    arr[:fade_samples] = (arr[:fade_samples].astype(np.float32) * ramp).astype(np.int16)
-    return arr.tobytes()
-
-
-# ── Voice Management Handlers ───────────────────────────────
-
-async def handle_voice_upload(ws, payload: dict) -> None:
-    name = (payload.get("name") or "").strip()
-    samples = payload.get("samples") or []
-    if not name or not samples:
-        logger.warning("voice_upload: ungueltig (name=%r, samples=%d)", name, len(samples))
-        return
-    logger.info("Voice-Upload: '%s' (%d Samples)", name, len(samples))
-
-    try:
-        VOICES_DIR.mkdir(parents=True, exist_ok=True)
-        safe = sanitize_voice_name(name)
-        wav_path = VOICES_DIR / f"{safe}.wav"
-        txt_path = VOICES_DIR / f"{safe}.txt"
-
-        # Samples zusammenfuegen
-        buffers = [base64.b64decode(s.get("base64", "")) for s in samples]
-        with open(wav_path, "wb") as f:
-            for b in buffers:
-                f.write(b)
-        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)
-
-        # Transkription ueber whisper-bridge anfragen
-        logger.info("Transkribiere '%s' via whisper-bridge...", name)
-        text = await request_transcription(ws, wav_path, language="de")
-        if text and text.strip():
-            txt_path.write_text(text.strip(), encoding="utf-8")
-            logger.info("Voice '%s' komplett (txt: %s)", name, text[:80])
-            ref_text_for_response = text.strip()
-        else:
-            # KEIN Platzhalter mehr schreiben! Beim ersten echten TTS-Use wird
-            # on-the-fly nachtranskribiert. Wenn die whisper-bridge dann online
-            # ist, klappt's — sonst koennte der User die .txt manuell anlegen.
-            logger.warning("Voice '%s': Transkription fehlgeschlagen — .txt bleibt leer, "
-                           "wird on-the-fly bei erstem Render nachgezogen", name)
-            ref_text_for_response = ""
-
-        await _send(ws, "xtts_voice_saved", {
-            "name": name, "size": int(size_kb * 1024), "refText": ref_text_for_response,
-        })
-        # Liste aktualisieren
-        await handle_list_voices(ws)
-    except Exception as e:
-        logger.exception("voice_upload Fehler")
-        await _send(ws, "xtts_voice_saved", {"name": name, "error": str(e)[:200]})
-
-
-async def handle_list_voices(ws) -> None:
-    try:
-        voices = []
-        if VOICES_DIR.exists():
-            for wav in sorted(VOICES_DIR.glob("*.wav")):
-                txt = wav.with_suffix(".txt")
-                voices.append({
-                    "name": wav.stem,
-                    "file": wav.name,
-                    "size": wav.stat().st_size,
-                    "hasRefText": txt.exists(),
-                })
-        logger.info("Stimmen-Liste: %d", len(voices))
-        await _send(ws, "xtts_voices_list", {"voices": voices})
-    except Exception:
-        logger.exception("handle_list_voices Fehler")
-
-
-async def handle_delete_voice(ws, payload: dict) -> None:
-    name = (payload.get("name") or "").strip()
-    if not name:
-        return
-    try:
-        wav, txt = voice_paths(name)
-        for p in (wav, txt):
-            if p.exists():
-                p.unlink()
-                logger.info("Voice geloescht: %s", p)
-        await handle_list_voices(ws)
-    except Exception:
-        logger.exception("handle_delete_voice Fehler")
-
-
-# Letzte diagnostisch-gesetzte Voice (verhindert Endlos-Preload bei jedem config)
-_last_diag_voice = ""
-
-
-async def handle_voice_preload(ws, payload: dict, runner: F5Runner) -> None:
-    voice = (payload.get("voice") or "").strip()
-    request_id = payload.get("requestId", "")
-    logger.info("Voice-Preload angefordert: '%s'", voice or "default")
-
-    try:
-        ref_wav, ref_txt = voice_paths(voice) if voice else (None, None)
-        if voice and (not ref_wav or not ref_wav.exists()):
-            await _send(ws, "voice_ready", {"voice": voice, "requestId": request_id, "error": "voice-file-not-found"})
-            return
-
-        # Ref-Text sicherstellen (falls nur WAV da ist)
-        if voice and ref_txt and not ref_txt.exists():
-            text = await request_transcription(ws, ref_wav, language="de")
-            if text:
-                ref_txt.write_text(text.strip(), encoding="utf-8")
-                logger.info("Referenz-Text beim Preload nachgezogen")
-
-        # Dummy-Render zum Warmup
-        t0 = time.time()
-        await _do_tts(ws, runner, "ja.", voice, f"preload-{request_id}", "", "de")
-        ms = int((time.time() - t0) * 1000)
-        await _send(ws, "voice_ready", {"voice": voice, "requestId": request_id, "loadMs": ms})
-    except Exception as e:
-        logger.exception("Voice-Preload Fehler")
-        await _send(ws, "voice_ready", {"voice": voice, "requestId": request_id, "error": str(e)[:200]})
-
-
-# ── Haupt-Loop ──────────────────────────────────────────────
-
-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
-    global _last_diag_voice
-
-    while True:
-        scheme = "wss" if use_tls else "ws"
-        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}/ws?token={RVS_TOKEN}"
-        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, max_size=50 * 1024 * 1024) as ws:
-                logger.info("RVS verbunden")
-                retry_s = 2
-                tls_fallback_tried = False
-
-                # Status-Broadcast: erst loading, dann ready nach erfolgreichem Load.
-                # Modell wird hier (nicht ausserhalb der Schleife) gestartet damit
-                # der Loading-Status auch wirklich uebertragen werden kann.
-                async def _load_with_status():
-                    if runner.model is not None:
-                        await _broadcast_status(ws, "ready",
-                                                model=runner.model_id,
-                                                loadSeconds=runner.last_load_seconds)
-                        return
-                    await _broadcast_status(ws, "loading", model=runner.model_id)
-                    try:
-                        await runner.ensure_loaded()
-                        await _broadcast_status(ws, "ready",
-                                                model=runner.model_id,
-                                                loadSeconds=runner.last_load_seconds)
-                    except Exception as e:
-                        await _broadcast_status(ws, "error", error=str(e)[:200])
-                asyncio.create_task(_load_with_status())
-
-                # TTS-Worker fuer diese Verbindung starten
-                worker = asyncio.create_task(_tts_worker(ws, runner))
-
-                try:
-                    async for raw in ws:
-                        try:
-                            msg = json.loads(raw)
-                        except Exception:
-                            continue
-                        mtype = msg.get("type", "")
-                        payload = msg.get("payload", {}) or {}
-
-                        if mtype == "xtts_request":
-                            await _tts_queue.put((
-                                payload.get("text", ""),
-                                payload.get("voice", "") or "",
-                                payload.get("requestId", ""),
-                                payload.get("messageId", ""),
-                                payload.get("language", "de"),
-                            ))
-                        elif mtype == "voice_upload":
-                            asyncio.create_task(handle_voice_upload(ws, payload))
-                        elif mtype == "xtts_list_voices":
-                            asyncio.create_task(handle_list_voices(ws))
-                        elif mtype == "xtts_delete_voice":
-                            asyncio.create_task(handle_delete_voice(ws, payload))
-                        elif mtype == "voice_preload":
-                            asyncio.create_task(handle_voice_preload(ws, payload, runner))
-                        elif mtype == "stt_response":
-                            # Antwort auf unseren internen Transkriptions-Request
-                            req_id = payload.get("requestId", "")
-                            fut = _pending_stt.get(req_id)
-                            if fut and not fut.done():
-                                if payload.get("error"):
-                                    fut.set_result(None)
-                                else:
-                                    fut.set_result(payload.get("text") or "")
-                        elif mtype == "config":
-                            # F5-TTS-Settings aktualisieren (Modell, cfg_strength, nfe)
-                            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:
-                                _last_diag_voice = v
-                                asyncio.create_task(handle_voice_preload(
-                                    ws, {"voice": v, "source": "diagnostic"}, runner,
-                                ))
-                            elif not v:
-                                _last_diag_voice = ""
-                finally:
-                    worker.cancel()
-                    try:
-                        await worker
-                    except asyncio.CancelledError:
-                        pass
-        except Exception as e:
-            logger.warning("Verbindung verloren: %s", e)
-            if use_tls and RVS_TLS_FALLBACK and not tls_fallback_tried:
-                logger.info("TLS fehlgeschlagen — Fallback auf ws://")
-                use_tls = False
-                tls_fallback_tried = True
-                continue
-            await asyncio.sleep(min(retry_s, 30))
-            retry_s = min(retry_s * 2, 30)
-
-
-async def main() -> None:
-    if not RVS_HOST:
-        logger.error("RVS_HOST nicht gesetzt — Abbruch")
-        sys.exit(1)
-    VOICES_DIR.mkdir(parents=True, exist_ok=True)
-    runner = F5Runner()
-    await run_loop(runner)
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        sys.exit(0)
@@ -1,5 +0,0 @@
-f5-tts>=1.0.0
-websockets>=12.0
-numpy>=1.24
-soundfile>=0.12
-requests>=2.31
@@ -0,0 +1,8 @@
+{
+  "name": "aria-xtts-bridge",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "ws": "^8.16.0"
+  }
+}
@@ -1,14 +0,0 @@
-FROM nvidia/cuda:12.2.2-cudnn8-runtime-ubuntu22.04
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    python3 python3-pip ffmpeg \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip3 install --no-cache-dir -r requirements.txt
-
-COPY bridge.py .
-
-CMD ["python3", "bridge.py"]
@@ -1,285 +0,0 @@
-#!/usr/bin/env python3
-"""
-ARIA Whisper Bridge — laeuft auf der Gamebox (RTX 3060).
-
-Empfaengt stt_request via RVS → FFmpeg-Konvertierung → faster-whisper auf GPU
-→ sendet stt_response zurueck an die aria-bridge.
-
-Env:
-  RVS_HOST, RVS_PORT, RVS_TLS, RVS_TLS_FALLBACK, RVS_TOKEN
-  WHISPER_MODEL          Default: small
-  WHISPER_DEVICE         Default: cuda
-  WHISPER_COMPUTE_TYPE   Default: float16
-  WHISPER_LANGUAGE       Default: de
-"""
-import asyncio
-import base64
-import json
-import logging
-import os
-import subprocess
-import sys
-import tempfile
-import time
-from typing import Optional
-
-import numpy as np
-import websockets
-from faster_whisper import WhisperModel
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%H:%M:%S",
-)
-logger = logging.getLogger("whisper-bridge")
-
-RVS_HOST = os.getenv("RVS_HOST", "").strip()
-RVS_PORT = int(os.getenv("RVS_PORT", "443"))
-RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
-RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
-RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
-
-WHISPER_MODEL = os.getenv("WHISPER_MODEL", "small")
-WHISPER_DEVICE = os.getenv("WHISPER_DEVICE", "cuda")
-WHISPER_COMPUTE_TYPE = os.getenv("WHISPER_COMPUTE_TYPE", "float16")
-WHISPER_LANGUAGE = os.getenv("WHISPER_LANGUAGE", "de")
-
-ALLOWED_MODELS = {"tiny", "base", "small", "medium", "large-v3"}
-
-
-class WhisperRunner:
-    """Haelt das Whisper-Modell. Hot-Swap bei Konfig-Wechsel via ensure_loaded()."""
-
-    def __init__(self) -> None:
-        self.model_size: str = WHISPER_MODEL
-        self.model: Optional[WhisperModel] = None
-        self._lock = asyncio.Lock()
-
-    def _load_blocking(self, size: str) -> None:
-        logger.info(
-            "Lade Whisper '%s' (device=%s, compute=%s)",
-            size, WHISPER_DEVICE, WHISPER_COMPUTE_TYPE,
-        )
-        t0 = time.time()
-        self.model = WhisperModel(
-            size, device=WHISPER_DEVICE, compute_type=WHISPER_COMPUTE_TYPE,
-        )
-        self.model_size = size
-        logger.info("Whisper '%s' geladen in %.1fs", size, time.time() - t0)
-
-    async def ensure_loaded(self, desired_size: str) -> None:
-        if desired_size not in ALLOWED_MODELS:
-            logger.warning("Ungueltiges Whisper-Modell '%s' — nutze %s", desired_size, WHISPER_MODEL)
-            desired_size = WHISPER_MODEL
-        async with self._lock:
-            if self.model is not None and self.model_size == desired_size:
-                return
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, self._load_blocking, desired_size)
-
-    async def transcribe(self, audio: np.ndarray, language: str) -> tuple[str, float]:
-        if self.model is None:
-            return "", 0.0
-
-        def _run():
-            segments, info = self.model.transcribe(
-                audio, language=language, beam_size=5, vad_filter=True,
-            )
-            text = " ".join(seg.text.strip() for seg in segments)
-            return text, info.duration
-
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, _run)
-
-
-def ffmpeg_to_float32(audio_b64: str, mime_type: str) -> np.ndarray:
-    """Dekodiert beliebiges Audio-Format → 16kHz mono float32 PCM."""
-    if "mp4" in mime_type or "m4a" in mime_type or "aac" in mime_type:
-        ext = ".mp4"
-    elif "wav" in mime_type:
-        ext = ".wav"
-    elif "ogg" in mime_type or "opus" in mime_type:
-        ext = ".ogg"
-    else:
-        ext = ".bin"
-
-    in_fh = tempfile.NamedTemporaryFile(suffix=ext, delete=False)
-    try:
-        in_fh.write(base64.b64decode(audio_b64))
-        in_fh.close()
-        out_path = in_fh.name + ".raw"
-        cmd = ["ffmpeg", "-y", "-i", in_fh.name, "-ar", "16000", "-ac", "1", "-f", "f32le", out_path]
-        result = subprocess.run(cmd, capture_output=True, timeout=30)
-        if result.returncode != 0:
-            logger.error("FFmpeg Fehler: %s", result.stderr.decode(errors="replace")[:300])
-            return np.zeros(0, dtype=np.float32)
-        try:
-            return np.fromfile(out_path, dtype=np.float32)
-        finally:
-            try:
-                os.unlink(out_path)
-            except OSError:
-                pass
-    finally:
-        try:
-            os.unlink(in_fh.name)
-        except OSError:
-            pass
-
-
-async def _send(ws, mtype: str, payload: dict) -> None:
-    try:
-        await ws.send(json.dumps({
-            "type": mtype,
-            "payload": payload,
-            "timestamp": int(time.time() * 1000),
-        }))
-    except Exception as e:
-        logger.warning("Send fehlgeschlagen (%s): %s", mtype, e)
-
-
-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
-    language = payload.get("language") or WHISPER_LANGUAGE
-
-    if not audio_b64:
-        await _send(ws, "stt_response", {"requestId": request_id, "error": "no-audio"})
-        return
-
-    try:
-        t_load = time.time()
-        await runner.ensure_loaded(model)
-        load_ms = int((time.time() - t_load) * 1000)
-
-        audio = ffmpeg_to_float32(audio_b64, mime_type)
-        if audio.size == 0:
-            await _send(ws, "stt_response", {"requestId": request_id, "error": "ffmpeg-failed"})
-            return
-        duration_s = len(audio) / 16000.0
-        logger.info("STT-Request: %.1fs Audio, model=%s, lang=%s", duration_s, runner.model_size, language)
-
-        t_stt = time.time()
-        text, detected_duration = await runner.transcribe(audio, language)
-        stt_ms = int((time.time() - t_stt) * 1000)
-
-        logger.info("STT-Ergebnis (%dms): '%s'", stt_ms, text[:100])
-
-        await _send(ws, "stt_response", {
-            "requestId": request_id,
-            "text": text.strip(),
-            "durationS": duration_s,
-            "sttMs": stt_ms,
-            "loadMs": load_ms,
-            "model": runner.model_size,
-        })
-    except Exception as e:
-        logger.exception("STT-Request fehlgeschlagen")
-        await _send(ws, "stt_response", {
-            "requestId": request_id,
-            "error": str(e)[:200],
-        })
-
-
-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
-
-    while True:
-        scheme = "wss" if use_tls else "ws"
-        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}/ws?token={RVS_TOKEN}"
-        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:
-                logger.info("RVS verbunden")
-                retry_s = 2
-                tls_fallback_tried = False
-
-                # Modell laden, dabei loading→ready broadcasten
-                async def _load_with_status():
-                    if runner.model is not None:
-                        await _broadcast_status(ws, "ready", model=runner.model_size)
-                        return
-                    await _broadcast_status(ws, "loading", model=WHISPER_MODEL)
-                    try:
-                        t0 = time.time()
-                        await runner.ensure_loaded(WHISPER_MODEL)
-                        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(_load_with_status())
-
-                async for raw in ws:
-                    try:
-                        msg = json.loads(raw)
-                    except Exception:
-                        continue
-                    mtype = msg.get("type", "")
-                    payload = msg.get("payload", {}) or {}
-
-                    if mtype == "stt_request":
-                        req_id = payload.get("requestId", "?")
-                        audio_len = len(payload.get("audio", ""))
-                        logger.info("stt_request empfangen (id=%s, %dKB Audio)",
-                                    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)
-                            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
-                        logger.debug("Unbeachteter Type: %s", mtype)
-        except Exception as e:
-            logger.warning("Verbindung verloren: %s", e)
-            if use_tls and RVS_TLS_FALLBACK and not tls_fallback_tried:
-                logger.info("TLS-Verbindung fehlgeschlagen — Fallback auf ws://")
-                use_tls = False
-                tls_fallback_tried = True
-                continue
-            await asyncio.sleep(min(retry_s, 30))
-            retry_s = min(retry_s * 2, 30)
-
-
-async def main() -> None:
-    if not RVS_HOST:
-        logger.error("RVS_HOST ist nicht gesetzt — Abbruch")
-        sys.exit(1)
-    runner = WhisperRunner()
-    await run_loop(runner)
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        sys.exit(0)
@@ -1,4 +0,0 @@
-faster-whisper==1.0.3
-websockets>=12.0
-numpy>=1.24
-requests>=2.31